@langchain/langgraph-sdk/dist/client/stream/messages.d.ts

Client library for interacting with the LangGraph API

import { AIMessage, ContentBlock, UsageMetadata } from "@langchain/core/messages";
import { ContentBlock as ContentBlock$1, FinalizedContentBlock, MessageMetadata, MessagesEvent, UsageInfo } from "@langchain/protocol";
import { ChatModelStreamEvent } from "@langchain/core/language_models/event";

//#region src/client/stream/messages.d.ts
type TextContentStream = AsyncIterable<string> & PromiseLike<string> & {
  full: AsyncIterable<string>;
};
type UsageMetadataStream = AsyncIterable<UsageMetadata> & PromiseLike<UsageMetadata | undefined>;
type ToolCallsStream = AsyncIterable<ContentBlock.Tools.ToolCall> & PromiseLike<Array<ContentBlock.Tools.ToolCall>> & {
  full: AsyncIterable<Array<ContentBlock.Tools.ToolCall>>;
};
/**
 * Mutable view of a streamed message as message and content-block events are
 * assembled into a single structure.
 */
interface AssembledMessage {
  id: string;
  namespace: string[];
  blocks: ContentBlock$1[];
  node?: string;
  runId?: string;
  usage?: UsageInfo;
  metadata?: MessageMetadata;
  finishMetadata?: Record<string, any>;
  finishReason?: string;
  error?: {
    message: string;
    code?: string;
  };
}
/**
 * Symbol keys for assembler → StreamingMessage communication.
 * Module-private: invisible to external consumers, accessible to
 * {@link StreamingMessageAssembler} within this file.
 */
declare const PUSH_TEXT: unique symbol;
declare const PUSH_REASONING: unique symbol;
declare const PUSH_EVENT: unique symbol;
declare const UPDATE_CONTEXT: unique symbol;
declare const FINISH: unique symbol;
declare const ERROR: unique symbol;
/**
 * Live streaming view of a single message lifecycle, matching the
 * in-process `ChatModelStream` dual-interface pattern.
 *
 * - `text` / `reasoning`: iterate for streaming deltas, or await for
 *   the full concatenated string after the message completes.
 * - `usage`: promise that resolves with token usage on message-finish.
 * - `blocks`: the assembled content blocks (updated as deltas arrive).
 *
 * Created by {@link StreamingMessageAssembler} and yielded by
 * the `session.messages` lazy getter.
 */
declare class StreamingMessage implements AsyncIterable<ChatModelStreamEvent>, PromiseLike<AIMessage> {
  #private;
  readonly id: string;
  readonly namespace: string[];
  node: string | undefined;
  readonly metadata: MessageMetadata | undefined;
  readonly assembled: AssembledMessage;
  constructor(assembled: AssembledMessage);
  get text(): TextContentStream;
  get reasoning(): TextContentStream;
  get usage(): UsageMetadataStream;
  get toolCalls(): ToolCallsStream;
  get output(): PromiseLike<AIMessage>;
  get blocks(): ContentBlock$1[];
  [Symbol.asyncIterator](): AsyncIterator<ChatModelStreamEvent>;
  then<TResult1 = AIMessage, TResult2 = never>(onfulfilled?: ((value: AIMessage) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
  [PUSH_EVENT](event: ChatModelStreamEvent): void;
  [UPDATE_CONTEXT](event: MessagesEvent): void;
  [PUSH_TEXT](delta: string): void;
  [PUSH_REASONING](delta: string): void;
  [FINISH](): void;
  [ERROR](): void;
}
/**
 * Public view yielded by message projections.
 *
 * `StreamingMessage` is PromiseLike so callers can still `await` a message
 * object directly, but TypeScript applies `Awaited<T>` to values produced by
 * `for await`. Exposing a non-thenable view keeps loop variables typed as the
 * streaming handle instead of as the finalized `AIMessage`.
 */
type StreamingMessageHandle = Omit<StreamingMessage, "then">;
/**
 * Emitted by `MessageAssembler.consume()` to describe how a message changed in
 * response to a single protocol event.
 */
type MessageAssemblyUpdate = {
  kind: "message-start";
  key: string;
  message: AssembledMessage;
  event: MessagesEvent;
} | {
  kind: "content-block-start" | "content-block-delta";
  key: string;
  message: AssembledMessage;
  index: number;
  block: ContentBlock$1;
  event: MessagesEvent;
} | {
  kind: "content-block-finish";
  key: string;
  message: AssembledMessage;
  index: number;
  block: FinalizedContentBlock;
  event: MessagesEvent;
} | {
  kind: "usage";
  key: string;
  message: AssembledMessage;
  event: MessagesEvent;
} | {
  kind: "message-finish";
  key: string;
  message: AssembledMessage;
  event: MessagesEvent;
} | {
  kind: "message-error";
  key: string;
  message: AssembledMessage;
  event: MessagesEvent;
};
/**
 * Incrementally assembles `messages` events into complete message objects.
 */
declare class MessageAssembler {
  private readonly activeMessages;
  private readonly activeByNamespaceNode;
  private readonly blockIndexByProtocolIndexAndType;
  /**
   * Applies a single message event and returns the resulting assembly update.
   *
   * Returns `undefined` when the event changes nothing, such as a delta
   * variant this version doesn't recognise. Those are ignored so that a
   * newer producer can't break the stream; `content-block-finish` still
   * carries the complete block.
   *
   * @param event - Incoming `messages` event to fold into the assembler state.
   */
  consume(event: MessagesEvent): MessageAssemblyUpdate | undefined;
  /**
   * Drop every message that started but never got `message-finish` or
   * `error`, e.g. because the run was cancelled mid-stream.
   *
   * @param namespace - Only abandon messages at or below this namespace.
   * @returns The abandoned messages.
   */
  abandonActive(namespace?: readonly string[]): AssembledMessage[];
  private clearActiveMessage;
  private resolveBlockIndex;
  private resolveFinishBlockIndex;
  private clearBlockIndexAliases;
}
//#endregion
export { AssembledMessage, MessageAssembler, MessageAssemblyUpdate, StreamingMessage, StreamingMessageHandle };
//# sourceMappingURL=messages.d.ts.map