injectAgent()

injectAgent() is the LangGraph adapter for Angular. It connects to a LangGraph Platform assistant, consumes the LangGraph SDK event stream, and projects the result into the runtime-neutral Agent contract used by @threadplane/chat.

Call it in an Angular injection context, usually as a component field initializer. The returned object exposes Angular Signals for UI state and async methods for user actions.

#Overloads

#No-arg form

injectAgent(): LangGraphAgent

Returns the default-typed agent. state() and value() are Record<string, unknown>. Use this form when your component does not need to read typed state fields.

import { injectAgent } from '@threadplane/langgraph';
 
readonly chat = injectAgent();
 
await this.chat.submit({ message: 'Hello' });

#Typed ref form (recommended for typed state)

injectAgent<T>(ref: AgentRef<T>): LangGraphAgent<T>

Pass a typed ref handle created with createAgentRef<T>() from @threadplane/chat. Returns a LangGraphAgent<T> where state() and value() are typed as T. The same ref is passed to provideAgent() to bind the configuration.

import { createAgentRef } from '@threadplane/chat';
import { injectAgent, provideAgent } from '@threadplane/langgraph';
import type { BaseMessage } from '@langchain/core/messages';
 
// Declare the ref once (e.g. in agent.ts or app.config.ts):
export interface MyState {
  messages: BaseMessage[];
  summary: string;
}
export const MY_AGENT = createAgentRef<MyState>('my-agent');
 
// Register in app.config.ts providers:
provideAgent(MY_AGENT, {
  apiUrl: 'http://localhost:2024',
  assistantId: 'my-graph',
  threadId: () => localStorage.getItem('threadId') ?? undefined,
  onThreadId: (id) => localStorage.setItem('threadId', id),
});
 
// Inject in a component or service:
readonly chat = injectAgent(MY_AGENT);
// chat.value()  →  MyState
// chat.state()  →  MyState

createAgentRef<T>(debugName?) is exported from @threadplane/chat; the ref carries the state shape T. For typed interrupt payloads, pass the BagTemplate as the second generic at the inject site — injectAgent<T, Bag>(ref) — as shown in the Interrupts guide.

Pair it with provideAgent() at bootstrap to configure the API URL, assistant id, thread persistence, and transport:

import { bootstrapApplication } from '@angular/platform-browser';
import { provideAgent } from '@threadplane/langgraph';
import { createAgentRef } from '@threadplane/chat';
import { AppComponent } from './app/app.component';
 
export const MY_AGENT = createAgentRef('my-agent');
 
bootstrapApplication(AppComponent, {
  providers: [
    provideAgent(MY_AGENT, {
      apiUrl: 'http://localhost:2024',
      assistantId: 'my-graph',
      threadId: () => localStorage.getItem('threadId') ?? undefined,
      onThreadId: (id) => localStorage.setItem('threadId', id),
    }),
  ],
});

#Runtime-neutral surface

These fields are stable across runtime adapters and are what chat components consume.

#LangGraph-specific surface

injectAgent() also returns LangGraph-specific signals and helpers for apps that need the raw platform model:

• value() and hasValue() for raw state values.
• langGraphMessages(), langGraphToolCalls(), and langGraphHistory() for raw SDK-shaped data.
• history(), branch(), setBranch(), and experimentalBranchTree() for checkpoint and time-travel UIs.
• queue(), joinStream(), and switchThread() for persisted threads and queued runs.
• getSubagent(), getSubagentsByType(), and getSubagentsByMessage() for subgraph/subagent inspection.

#Submit and resume

Use the runtime-neutral submit shape for normal chat input:

await chat.submit({ message: 'Explain streaming in Angular' });

Resume an interrupt with resume; combine it with state when the resume action also needs to update graph state:

await chat.submit({
  resume: { approved: true },
  state: { reviewer: 'Ada' },
});

LangGraph run options are still accepted as the second argument:

await chat.submit(
  { message: 'Queue this run' },
  { multitaskStrategy: 'enqueue' },
);

#Regenerate semantics

regenerate(assistantMessageIndex) has replace semantics. It keeps the user message before the selected assistant message, removes the selected assistant message and every later message, synchronizes that rollback with LangGraph state when possible, then reruns with no new user message appended.

await chat.regenerate(3);

The method throws when the selected index is not an assistant message, when no preceding user message exists, or while another response is already loading.

#What's Next