Type safety

@langchain/angular is designed around agent-brand inference: pass typeof agent to the hook and get typed state, tool calls, and (for DeepAgents) subagent state maps back. Plain state generics still work for graphs that aren't built with the agent helpers.

Agent-brand inference

Pass typeof agent to infer state, tool-call union, and (for DeepAgents) subagent state map:

import { Component } from "@angular/core";
import type { agent } from "./agent";
import { injectStream } from "@langchain/angular";

@Component({
  /* ... */
})
export class ChatComponent {
  readonly stream = injectStream<typeof agent>({
    assistantId: "agent",
    apiUrl: "http://localhost:2024",
  });

  // stream.values() is inferred
  // stream.toolCalls() is a discriminated union of your tools
  // stream.subagents() carries discovery snapshots
}

The same inference works on injectStream<typeof agent>() and on the companion selector injectors when you pass a scoped target:

const messages = injectMessages(stream); // BaseMessage[]
const tools = injectToolCalls<typeof agent>(stream);
const state = injectValues<typeof agent>(stream);

Custom state types

For plain state shapes, pass the state directly. The second and third generic slots are InterruptType and ConfigurableType:

import { injectStream } from "@langchain/angular";
import type { BaseMessage } from "@langchain/core/messages";

interface MyState {
  messages: BaseMessage[];
  context?: string;
}

readonly stream = injectStream<MyState, { question: string }>({
  assistantId: "my-graph",
  apiUrl: "http://localhost:2024",
});

Passing the Stream Handle

Use the Angular-facing StreamApi<T> name when you need to annotate a stream handle in Angular app or library code. UseStreamReturn<T> and UseStreamResult<T> describe the same handle shape, but are mainly useful in shared utilities that intentionally use React-style naming.

• StreamApi<T> — preferred Angular name for the fully resolved return type of injectStream, provideStream, useStream, and StreamService.
• UseStreamReturn<T> — same stream handle shape, useful for utilities shared with other frontend packages.
• AnyStream — type-erased handle. Use when the child only forwards stream into selector injectors and doesn't care about the underlying state shape.

import type { AnyStream, StreamApi, UseStreamReturn } from "@langchain/angular";
import type { agent } from "./agent";

function acceptsAngularStream(stream: StreamApi<typeof agent>) {
  return stream.values();
}

function acceptsSharedStream(stream: UseStreamReturn<typeof agent>) {
  return stream.messages();
}

function passThroughToSelectors(
  stream,
  subgraph,
}: {
  stream: AnyStream;
  subgraph: SubgraphDiscoverySnapshot;
}) {
  return injectValues(stream, subgraph);
}

Type helpers

Helper	Use
InferStateType<T>	Unwraps a compiled graph / agent brand / agent tool array into its state shape.
InferToolCalls<T>	Derives a discriminated union of tool-call shapes.
InferToolOutput<T>	Derives a single tool's output type.
InferSubagentStates<T>	{ name: State, … } map derived from a DeepAgent brand.
WidenUpdateMessages<T>	Widens messages so both wire-format and BaseMessage instances typecheck in submit().
StreamSubmitOptions<State, Configurable>	Options shape accepted by submit().
AgentServerAdapter / HttpAgentServerAdapter	Custom-transport interface + convenience class. See Transports.
SelectorTarget / SubagentDiscoverySnapshot / SubgraphDiscoverySnapshot	For components that render scoped views. See Selectors / Subagents.
AssembledToolCall, ToolCallStatus	For rendering tool-call UI.
MessageMetadata, UseSubmissionQueueReturn, SubmissionQueueEntry	Companion-hook return shapes. See Selectors.

API reference