Subgraphs

from typing import Annotated, TypedDict
from langgraph.graph import END, START, StateGraph
from langgraph.graph.message import add_messages
 
class ResearchState(TypedDict):
    """Child state — deliberately has no `messages` key."""
    research_topic: str
    research_brief: str
 
class OrchestratorState(TypedDict):
    """Parent state — the transcript plus the shared channel."""
    messages: Annotated[list, add_messages]
    research_topic: str
    research_brief: str
 
async def research_node(state: ResearchState) -> dict:
    # Receives a topic, returns a brief. No transcript access.
    brief = await researcher.ainvoke(f"Topic: {state['research_topic']}")
    return {"research_brief": brief.content}
 
research_graph = StateGraph(ResearchState)
research_graph.add_node("research", research_node)
research_graph.add_edge(START, "research")
research_graph.add_edge("research", END)
compiled_research = research_graph.compile()
 
def route_after_orchestrate(state: OrchestratorState) -> str:
    # Writing a topic is what triggers delegation.
    return "research" if state.get("research_topic") else "answer"
 
parent = StateGraph(OrchestratorState)
parent.add_node("orchestrate", orchestrate_node)
parent.add_node("research", compiled_research)  # the compiled graph IS the node
parent.add_node("answer", answer_node)          # the only node that writes messages
parent.add_edge(START, "orchestrate")
parent.add_conditional_edges(
    "orchestrate", route_after_orchestrate, {"research": "research", "answer": "answer"}
)
parent.add_edge("research", "answer")
parent.add_edge("answer", END)
graph = parent.compile()

// In a shared file (e.g. agent.ts):
// import { createAgentRef } from '@threadplane/chat';
// export const ORCHESTRATOR = createAgentRef<OrchestratorState>('orchestrator');
 
// Configure in app.config.ts:
// provideAgent(ORCHESTRATOR, {
//   apiUrl: '...',
//   subagentToolNames: ['task', 'delegate_to_researcher'],
// });
 
const orchestrator = injectAgent(ORCHESTRATOR);
 
// All subagent streams (active and completed)
const subagents = computed(() => orchestrator.subagents());
 
// Only active ones
const running = computed(() =>
  [...orchestrator.subagents().values()].filter((subagent) =>
    subagent.status() === 'pending' || subagent.status() === 'running'
  )
);
const runningCount = computed(() => running().length);
 
// Lookup helpers for common UI paths
const specific = computed(() => orchestrator.getSubagent('research-tool-call-id'));
const researchers = computed(() =>
  orchestrator.getSubagentsByType('researcher')
);
 
// React to count changes
effect(() => {
  console.log(`${runningCount()} subagents currently running`);
});

// Access a specific subagent by its tool call ID
const researchAgent = computed(() =>
  orchestrator.getSubagent('research-tool-call-id')
);
 
// Or get the subagents spawned by a specific AI message with tool calls
const messageAgents = computed(() => {
  const message = selectedAiMessage();
  return message ? orchestrator.getSubagentsByMessage(message) : [];
});
 
// Track its progress
const researchStatus = computed(() => researchAgent()?.status());
const researchMessages = computed(() => researchAgent()?.messages() ?? []);

// In a shared file (e.g. agent.ts):
// import { createAgentRef } from '@threadplane/chat';
// export const PIPELINE = createAgentRef<PipelineState>('pipeline-orchestrator');
 
// Configure in app.config.ts:
// provideAgent(PIPELINE, {
//   apiUrl: '...',
//   subagentToolNames: ['task'],
//   filterSubagentMessages: true,
// });
 
const pipeline = injectAgent(PIPELINE);
 
// Derive a summary of all subagent states
const pipelineStatus = computed(() => {
  const agents = pipeline.subagents();
  const entries = [...agents.entries()];
 
  return {
    total: entries.length,
    pending: entries.filter(([, a]) => a.status() === 'pending').length,
    running: entries.filter(([, a]) => a.status() === 'running').length,
    done: entries.filter(([, a]) => a.status() === 'complete').length,
    failed: entries.filter(([, a]) => a.status() === 'error').length,
  };
});

// In a shared file (e.g. agent.ts):
// import { createAgentRef } from '@threadplane/chat';
// export const ORCHESTRATOR = createAgentRef<OrchestratorState>('orchestrator');
 
// Configure in app.config.ts:
// provideAgent(ORCHESTRATOR, {
//   apiUrl: '...',
//   filterSubagentMessages: true,  // Hide subagent messages from parent
//   subagentToolNames: ['task'],
// });
 
const orchestrator = injectAgent(ORCHESTRATOR);
 
// Parent messages only (no subagent chatter)
const parentMessages = computed(() => orchestrator.messages());

// Collect all failed subagents reactively
const failedAgents = computed(() =>
  [...orchestrator.subagents().entries()].filter(
    ([, agent]) => agent.status() === 'error'
  )
);
 
// One effect over the derived list — it re-runs as subagents appear and fail.
effect(() => {
  for (const [id] of failedAgents()) {
    console.error(`Subagent ${id} failed`);
    // Retry, surface to user, or fall back gracefully
  }
});