@illuma-ai/agents 1.0.81

package/src/types/graph.ts

@@ -0,0 +1,533 @@
+// src/types/graph.ts
+import type {
+  START,
+  StateType,
+  UpdateType,
+  StateGraph,
+  StateGraphArgs,
+  StateDefinition,
+  CompiledStateGraph,
+  BinaryOperatorAggregate,
+} from '@langchain/langgraph';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type {
+  BaseMessage,
+  AIMessageChunk,
+  SystemMessage,
+} from '@langchain/core/messages';
+import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { GoogleAIToolType } from '@langchain/google-common';
+import type { ToolMap, ToolEndEvent, GenericTool, LCTool } from '@/types/tools';
+import type { Providers, Callback, GraphNodeKeys } from '@/common';
+import type { StandardGraph, MultiAgentGraph } from '@/graphs';
+import type { ClientOptions } from '@/types/llm';
+import type {
+  RunStep,
+  RunStepDeltaEvent,
+  MessageDeltaEvent,
+  ReasoningDeltaEvent,
+} from '@/types/stream';
+import type { TokenCounter } from '@/types/run';
+
+/** Interface for bound model with stream and invoke methods */
+export interface ChatModel {
+  stream?: (
+    messages: BaseMessage[],
+    config?: RunnableConfig
+  ) => Promise<AsyncIterable<AIMessageChunk>>;
+  invoke: (
+    messages: BaseMessage[],
+    config?: RunnableConfig
+  ) => Promise<AIMessageChunk>;
+}
+
+export type GraphNode = GraphNodeKeys | typeof START;
+export type ClientCallback<T extends unknown[]> = (
+  graph: StandardGraph,
+  ...args: T
+) => void;
+
+export type ClientCallbacks = {
+  [Callback.TOOL_ERROR]?: ClientCallback<[Error, string]>;
+  [Callback.TOOL_START]?: ClientCallback<unknown[]>;
+  [Callback.TOOL_END]?: ClientCallback<unknown[]>;
+};
+
+export type SystemCallbacks = {
+  [K in keyof ClientCallbacks]: ClientCallbacks[K] extends ClientCallback<
+    infer Args
+  >
+    ? (...args: Args) => void
+    : never;
+};
+
+export type BaseGraphState = {
+  messages: BaseMessage[];
+  /**
+   * Structured response when using structured output mode.
+   * Contains the validated JSON response conforming to the configured schema.
+   */
+  structuredResponse?: Record<string, unknown>;
+};
+
+export type MultiAgentGraphState = BaseGraphState & {
+  agentMessages?: BaseMessage[];
+};
+
+export type IState = BaseGraphState;
+
+export interface EventHandler {
+  handle(
+    event: string,
+    data:
+      | StreamEventData
+      | ModelEndData
+      | RunStep
+      | RunStepDeltaEvent
+      | MessageDeltaEvent
+      | ReasoningDeltaEvent
+      | { result: ToolEndEvent },
+    metadata?: Record<string, unknown>,
+    graph?: StandardGraph | MultiAgentGraph
+  ): void | Promise<void>;
+}
+
+export type GraphStateChannels<T extends BaseGraphState> =
+  StateGraphArgs<T>['channels'];
+
+export type Workflow<
+  T extends BaseGraphState = BaseGraphState,
+  U extends Partial<T> = Partial<T>,
+  N extends string = string,
+> = StateGraph<T, U, N>;
+
+export type CompiledWorkflow<
+  T extends BaseGraphState = BaseGraphState,
+  U extends Partial<T> = Partial<T>,
+  N extends string = string,
+> = CompiledStateGraph<T, U, N>;
+
+export type CompiledStateWorkflow = CompiledStateGraph<
+  StateType<{
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  }>,
+  UpdateType<{
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  }>,
+  string,
+  {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  },
+  {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  },
+  StateDefinition
+>;
+
+export type CompiledMultiAgentWorkflow = CompiledStateGraph<
+  StateType<{
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  }>,
+  UpdateType<{
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  }>,
+  string,
+  {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  },
+  {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  },
+  StateDefinition
+>;
+
+export type CompiledAgentWorfklow = CompiledStateGraph<
+  {
+    messages: BaseMessage[];
+  },
+  {
+    messages?: BaseMessage[] | undefined;
+  },
+  '__start__' | `agent=${string}` | `tools=${string}`,
+  {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  },
+  {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  },
+  StateDefinition,
+  {
+    [x: `agent=${string}`]: Partial<BaseGraphState>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [x: `tools=${string}`]: any;
+  }
+>;
+
+export type SystemRunnable =
+  | Runnable<
+      BaseMessage[],
+      (BaseMessage | SystemMessage)[],
+      RunnableConfig<Record<string, unknown>>
+    >
+  | undefined;
+
+/**
+ * Optional compile options passed to workflow.compile().
+ * These are intentionally untyped to avoid coupling to library internals.
+ */
+export type CompileOptions = {
+  // A checkpointer instance (e.g., MemorySaver, SQL saver)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  checkpointer?: any;
+  interruptBefore?: string[];
+  interruptAfter?: string[];
+};
+
+export type EventStreamCallbackHandlerInput =
+  Parameters<CompiledWorkflow['streamEvents']>[2] extends Omit<
+    infer T,
+    'autoClose'
+  >
+    ? T
+    : never;
+
+export type StreamChunk =
+  | (ChatGenerationChunk & {
+      message: AIMessageChunk;
+    })
+  | AIMessageChunk;
+
+/**
+ * Data associated with a StreamEvent.
+ */
+export type StreamEventData = {
+  /**
+   * The input passed to the runnable that generated the event.
+   * Inputs will sometimes be available at the *START* of the runnable, and
+   * sometimes at the *END* of the runnable.
+   * If a runnable is able to stream its inputs, then its input by definition
+   * won't be known until the *END* of the runnable when it has finished streaming
+   * its inputs.
+   */
+  input?: unknown;
+  /**
+   * The output of the runnable that generated the event.
+   * Outputs will only be available at the *END* of the runnable.
+   * For most runnables, this field can be inferred from the `chunk` field,
+   * though there might be some exceptions for special cased runnables (e.g., like
+   * chat models), which may return more information.
+   */
+  output?: unknown;
+  /**
+   * A streaming chunk from the output that generated the event.
+   * chunks support addition in general, and adding them up should result
+   * in the output of the runnable that generated the event.
+   */
+  chunk?: StreamChunk;
+  /**
+   * Runnable config for invoking other runnables within handlers.
+   */
+  config?: RunnableConfig;
+  /**
+   * Custom result from the runnable that generated the event.
+   */
+  result?: unknown;
+  /**
+   * Custom field to indicate the event was manually emitted, and may have been handled already
+   */
+  emitted?: boolean;
+};
+
+/**
+ * A streaming event.
+ *
+ * Schema of a streaming event which is produced from the streamEvents method.
+ */
+export type StreamEvent = {
+  /**
+   * Event names are of the format: on_[runnable_type]_(start|stream|end).
+   *
+   * Runnable types are one of:
+   * - llm - used by non chat models
+   * - chat_model - used by chat models
+   * - prompt --  e.g., ChatPromptTemplate
+   * - tool -- LangChain tools
+   * - chain - most Runnables are of this type
+   *
+   * Further, the events are categorized as one of:
+   * - start - when the runnable starts
+   * - stream - when the runnable is streaming
+   * - end - when the runnable ends
+   *
+   * start, stream and end are associated with slightly different `data` payload.
+   *
+   * Please see the documentation for `EventData` for more details.
+   */
+  event: string;
+  /** The name of the runnable that generated the event. */
+  name: string;
+  /**
+   * An randomly generated ID to keep track of the execution of the given runnable.
+   *
+   * Each child runnable that gets invoked as part of the execution of a parent runnable
+   * is assigned its own unique ID.
+   */
+  run_id: string;
+  /**
+   * Tags associated with the runnable that generated this event.
+   * Tags are always inherited from parent runnables.
+   */
+  tags?: string[];
+  /** Metadata associated with the runnable that generated this event. */
+  metadata: Record<string, unknown>;
+  /**
+   * Event data.
+   *
+   * The contents of the event data depend on the event type.
+   */
+  data: StreamEventData;
+};
+
+export type GraphConfig = {
+  provider: string;
+  thread_id?: string;
+  run_id?: string;
+};
+
+export type PartMetadata = {
+  progress?: number;
+  asset_pointer?: string;
+  status?: string;
+  action?: boolean;
+  output?: string;
+};
+
+export type ModelEndData =
+  | (StreamEventData & { output: AIMessageChunk | undefined })
+  | undefined;
+export type GraphTools = GenericTool[] | BindToolsInput[] | GoogleAIToolType[];
+export type StandardGraphInput = {
+  runId?: string;
+  signal?: AbortSignal;
+  agents: AgentInputs[];
+  tokenCounter?: TokenCounter;
+  indexTokenCountMap?: Record<string, number>;
+};
+
+export type GraphEdge = {
+  /** Agent ID, use a list for multiple sources */
+  from: string | string[];
+  /** Agent ID, use a list for multiple destinations */
+  to: string | string[];
+  description?: string;
+  /** Can return boolean or specific destination(s) */
+  condition?: (state: BaseGraphState) => boolean | string | string[];
+  /** 'handoff' creates tools for dynamic routing, 'direct' creates direct edges, which also allow parallel execution */
+  edgeType?: 'handoff' | 'direct';
+  /**
+   * For direct edges: Optional prompt to add when transitioning through this edge.
+   * String prompts can include variables like {results} which will be replaced with
+   * messages from startIndex onwards. When {results} is used, excludeResults defaults to true.
+   *
+   * For handoff edges: Description for the input parameter that the handoff tool accepts,
+   * allowing the supervisor to pass specific instructions/context to the transferred agent.
+   */
+  prompt?:
+    | string
+    | ((
+        messages: BaseMessage[],
+        runStartIndex: number
+      ) => string | Promise<string> | undefined);
+  /**
+   * When true, excludes messages from startIndex when adding prompt.
+   * Automatically set to true when {results} variable is used in prompt.
+   */
+  excludeResults?: boolean;
+  /**
+   * For handoff edges: Customizes the parameter name for the handoff input.
+   * Defaults to "instructions" if not specified.
+   * Only applies when prompt is provided for handoff edges.
+   */
+  promptKey?: string;
+};
+
+export type MultiAgentGraphInput = StandardGraphInput & {
+  edges: GraphEdge[];
+};
+
+/**
+ * Structured output mode determines how the agent returns structured data.
+ * - 'tool': Uses tool calling to return structured output (works with all tool-calling models)
+ * - 'provider': Uses provider-native structured output via LangChain's jsonMode (OpenAI, Anthropic, etc.)
+ * - 'native': Uses provider's constrained decoding API directly for guaranteed schema compliance
+ *   (Anthropic output_config.format, OpenAI response_format.json_schema). Falls back to 'tool' for unsupported providers.
+ * - 'auto': Automatically selects the best strategy — 'native' for supported providers, 'tool' for others
+ */
+export type StructuredOutputMode = 'tool' | 'provider' | 'native' | 'auto';
+
+/**
+ * Resolved method used internally after mode resolution.
+ * Maps to LangChain's withStructuredOutput method parameter plus our native path.
+ */
+export type ResolvedStructuredOutputMethod = 'functionCalling' | 'jsonMode' | 'jsonSchema' | 'native' | undefined;
+
+/**
+ * Error thrown when the model refuses to produce structured output due to safety policies.
+ */
+export class StructuredOutputRefusalError extends Error {
+  constructor(public refusalText: string) {
+    super(`Model refused to produce structured output: ${refusalText}`);
+    this.name = 'StructuredOutputRefusalError';
+  }
+}
+
+/**
+ * Error thrown when the structured output response was truncated due to max_tokens.
+ */
+export class StructuredOutputTruncatedError extends Error {
+  constructor(public stopReason: string) {
+    super(
+      `Structured output was truncated (stop_reason: ${stopReason}). ` +
+      `Increase max_tokens to allow the full JSON response to be generated.`
+    );
+    this.name = 'StructuredOutputTruncatedError';
+  }
+}
+
+/**
+ * Configuration for structured JSON output from agents.
+ * When configured, the agent will return a validated JSON response
+ * instead of streaming text.
+ */
+export interface StructuredOutputConfig {
+  /**
+   * JSON Schema defining the output structure.
+   * The model will be forced to return data conforming to this schema.
+   */
+  schema: Record<string, unknown>;
+  /**
+   * Name for the structured output format (used in tool mode).
+   * @default 'StructuredResponse'
+   */
+  name?: string;
+  /**
+   * Description of what the structured output represents.
+   * Helps the model understand the expected format.
+   */
+  description?: string;
+  /**
+   * Output mode strategy.
+   * @default 'auto'
+   */
+  mode?: StructuredOutputMode;
+  /**
+   * Enable strict schema validation.
+   * When true, the response must exactly match the schema.
+   * @default true
+   */
+  strict?: boolean;
+  /**
+   * Error handling configuration.
+   * - true: Auto-retry on validation errors (default)
+   * - false: Throw error on validation failure
+   * - string: Custom error message for retry
+   */
+  handleErrors?: boolean | string;
+  /**
+   * Maximum number of retry attempts on validation failure.
+   * @default 2
+   */
+  maxRetries?: number;
+  /**
+   * Include the raw AI message along with structured response.
+   * Useful for debugging.
+   * @default false
+   */
+  includeRaw?: boolean;
+}
+
+/**
+ * Database/API structured output format (snake_case with enabled flag).
+ * This matches the format stored in MongoDB and sent from frontends.
+ */
+export interface StructuredOutputInput {
+  /** Whether structured output is enabled */
+  enabled?: boolean;
+  /** JSON Schema defining the expected response structure */
+  schema?: Record<string, unknown>;
+  /** Name identifier for the structured output */
+  name?: string;
+  /** Description of what the structured output represents */
+  description?: string;
+  /** Mode for structured output: 'tool' | 'provider' | 'native' | 'auto' */
+  mode?: StructuredOutputMode;
+  /** Whether to enforce strict schema validation */
+  strict?: boolean;
+}
+
+export interface AgentInputs {
+  agentId: string;
+  /** Human-readable name for the agent (used in handoff context). Defaults to agentId if not provided. */
+  name?: string;
+  toolEnd?: boolean;
+  toolMap?: ToolMap;
+  tools?: GraphTools;
+  provider: Providers;
+  instructions?: string;
+  streamBuffer?: number;
+  maxContextTokens?: number;
+  clientOptions?: ClientOptions;
+  additional_instructions?: string;
+  reasoningKey?: 'reasoning_content' | 'reasoning';
+  /** Format content blocks as strings (for legacy compatibility i.e. Ollama/Azure Serverless) */
+  useLegacyContent?: boolean;
+  /**
+   * Tool definitions for all tools, including deferred and programmatic.
+   * Used for tool search and programmatic tool calling.
+   * Maps tool name to LCTool definition.
+   */
+  toolRegistry?: Map<string, LCTool>;
+  /**
+   * Dynamic context that changes per-request (e.g., current time, user info).
+   * This is injected as a user message rather than system prompt to preserve cache.
+   * Keeping this separate from instructions ensures the system message stays static
+   * and can be cached by Bedrock/Anthropic prompt caching.
+   */
+  dynamicContext?: string;
+  /**
+   * Structured output configuration (camelCase).
+   * When set, disables streaming and returns a validated JSON response
+   * conforming to the specified schema.
+   */
+  structuredOutput?: StructuredOutputConfig;
+  /**
+   * Structured output configuration (snake_case - database/API format).
+   * Alternative to structuredOutput for compatibility with MongoDB/frontend.
+   * Uses an `enabled` flag to control activation.
+   * @deprecated Use structuredOutput instead when possible
+   */
+  structured_output?: StructuredOutputInput;
+  /**
+   * Serializable tool definitions for event-driven execution.
+   * When provided, ToolNode operates in event-driven mode, dispatching
+   * ON_TOOL_EXECUTE events instead of invoking tools directly.
+   */
+  toolDefinitions?: LCTool[];
+  /**
+   * Tool names discovered from previous conversation history.
+   * These tools will be pre-marked as discovered so they're included
+   * in tool binding without requiring tool_search.
+   */
+  discoveredTools?: string[];
+  /**
+   * Optional callback for summarizing messages that were pruned from context.
+   * When provided, discarded messages are summarized by the caller (e.g., Ranger)
+   * using a cheap LLM call, and the summary is prepended to the context.
+   */
+  summarizeCallback?: (messagesToRefine: import('@langchain/core/messages').BaseMessage[]) => Promise<string | undefined>;
+}

package/src/types/index.ts

@@ -0,0 +1,6 @@
+// src/types/index.ts
+export * from './graph';
+export * from './llm';
+export * from './run';
+export * from './stream';
+export * from './tools';

package/src/types/llm.ts

@@ -0,0 +1,140 @@
+// src/types/llm.ts
+import { ChatMistralAI } from '@langchain/mistralai';
+import type {
+  BindToolsInput,
+  BaseChatModelParams,
+} from '@langchain/core/language_models/chat_models';
+import type {
+  OpenAIChatInput,
+  ChatOpenAIFields,
+  AzureOpenAIInput,
+  ClientOptions as OAIClientOptions,
+} from '@langchain/openai';
+import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
+import type { GeminiGenerationConfig } from '@langchain/google-common';
+import type { ChatVertexAIInput } from '@langchain/google-vertexai';
+import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
+import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
+import type { ChatBedrockConverseInput } from '@langchain/aws';
+import type { ChatMistralAIInput } from '@langchain/mistralai';
+import type { RequestOptions } from '@google/generative-ai';
+import type { StructuredTool } from '@langchain/core/tools';
+import type { AnthropicInput } from '@langchain/anthropic';
+import type { Runnable } from '@langchain/core/runnables';
+import type { OpenAI as OpenAIClient } from 'openai';
+import type { ChatXAIInput } from '@langchain/xai';
+import {
+  AzureChatOpenAI,
+  ChatDeepSeek,
+  ChatMoonshot,
+  ChatOpenAI,
+  ChatXAI,
+} from '@/llm/openai';
+import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
+import { CustomAnthropic } from '@/llm/anthropic';
+import { ChatOpenRouter } from '@/llm/openrouter';
+import { ChatVertexAI } from '@/llm/vertexai';
+import { Providers } from '@/common';
+
+export type AzureClientOptions = Partial<OpenAIChatInput> &
+  Partial<AzureOpenAIInput> & {
+    openAIApiKey?: string;
+    openAIApiVersion?: string;
+    openAIBasePath?: string;
+    deploymentName?: string;
+  } & BaseChatModelParams & {
+    configuration?: OAIClientOptions;
+  };
+export type ThinkingConfig = AnthropicInput['thinking'];
+export type ChatOpenAIToolType =
+  | BindToolsInput
+  | OpenAIClient.ChatCompletionTool;
+export type CommonToolType = StructuredTool | ChatOpenAIToolType;
+export type AnthropicReasoning = {
+  thinking?: ThinkingConfig | boolean;
+  thinkingBudget?: number;
+};
+export type OpenAIClientOptions = ChatOpenAIFields;
+export type AnthropicClientOptions = AnthropicInput & {
+  promptCache?: boolean;
+};
+export type MistralAIClientOptions = ChatMistralAIInput;
+export type VertexAIClientOptions = ChatVertexAIInput & {
+  includeThoughts?: boolean;
+};
+export type BedrockAnthropicInput = ChatBedrockConverseInput & {
+  additionalModelRequestFields?: ChatBedrockConverseInput['additionalModelRequestFields'] &
+    AnthropicReasoning;
+  promptCache?: boolean;
+};
+export type BedrockConverseClientOptions = ChatBedrockConverseInput;
+export type BedrockAnthropicClientOptions = BedrockAnthropicInput;
+export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
+  customHeaders?: RequestOptions['customHeaders'];
+  thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+};
+export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
+export type XAIClientOptions = ChatXAIInput;
+
+export type ClientOptions =
+  | OpenAIClientOptions
+  | AzureClientOptions
+  | AnthropicClientOptions
+  | MistralAIClientOptions
+  | VertexAIClientOptions
+  | BedrockConverseClientOptions
+  | GoogleClientOptions
+  | DeepSeekClientOptions
+  | XAIClientOptions;
+
+export type SharedLLMConfig = {
+  provider: Providers;
+  _lc_stream_delay?: number;
+};
+
+export type LLMConfig = SharedLLMConfig &
+  ClientOptions & {
+    /** Optional provider fallbacks in order of attempt */
+    fallbacks?: Array<{ provider: Providers; clientOptions?: ClientOptions }>;
+  };
+
+export type ProviderOptionsMap = {
+  [Providers.AZURE]: AzureClientOptions;
+  [Providers.OPENAI]: OpenAIClientOptions;
+  [Providers.GOOGLE]: GoogleClientOptions;
+  [Providers.VERTEXAI]: VertexAIClientOptions;
+  [Providers.DEEPSEEK]: DeepSeekClientOptions;
+  [Providers.ANTHROPIC]: AnthropicClientOptions;
+  [Providers.MISTRALAI]: MistralAIClientOptions;
+  [Providers.MISTRAL]: MistralAIClientOptions;
+  [Providers.OPENROUTER]: ChatOpenRouterCallOptions;
+  [Providers.BEDROCK]: BedrockConverseClientOptions;
+  [Providers.XAI]: XAIClientOptions;
+  [Providers.MOONSHOT]: OpenAIClientOptions;
+};
+
+export type ChatModelMap = {
+  [Providers.XAI]: ChatXAI;
+  [Providers.OPENAI]: ChatOpenAI;
+  [Providers.AZURE]: AzureChatOpenAI;
+  [Providers.DEEPSEEK]: ChatDeepSeek;
+  [Providers.VERTEXAI]: ChatVertexAI;
+  [Providers.ANTHROPIC]: CustomAnthropic;
+  [Providers.MISTRALAI]: ChatMistralAI;
+  [Providers.MISTRAL]: ChatMistralAI;
+  [Providers.OPENROUTER]: ChatOpenRouter;
+  [Providers.BEDROCK]: CustomChatBedrockConverse;
+  [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
+  [Providers.MOONSHOT]: ChatMoonshot;
+};
+
+export type ChatModelConstructorMap = {
+  [P in Providers]: new (config: ProviderOptionsMap[P]) => ChatModelMap[P];
+};
+
+export type ChatModelInstance = ChatModelMap[Providers];
+
+export type ModelWithTools = ChatModelInstance & {
+  bindTools(tools: CommonToolType[]): Runnable;
+};

package/src/types/messages.ts

@@ -0,0 +1,4 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { BaseMessage } from '@langchain/core/messages';
+export type AnthropicMessages = Array<AnthropicMessage | BaseMessage>;
+export type AnthropicMessage = Anthropic.MessageParam;