fix(core): Adds typing for model streamEvents events, makes v2 the default

langchain-core/src/language_models/base.ts

@@ -7,11 +7,8 @@ import {
   StringPromptValue,
   ChatPromptValue,
 } from "../prompt_values.js";
-import {
-  type BaseMessage,
-  type BaseMessageLike,
-  type MessageContent,
-} from "../messages/base.js";
+import { type BaseMessage, type MessageContent } from "../messages/base.js";
+import type { BaseLanguageModelInput } from "./types.js";
 import { coerceMessageLikeToMessage } from "../messages/utils.js";
 import { type LLMResult } from "../outputs.js";
 import { CallbackManager, Callbacks } from "../callbacks/manager.js";
@@ -249,10 +246,7 @@ export interface BaseFunctionCallOptions extends BaseLanguageModelCallOptions {
   functions?: FunctionDefinition[];
 }
 
-export type BaseLanguageModelInput =
-  | BasePromptValueInterface
-  | string
-  | BaseMessageLike[];
+export type { BaseLanguageModelInput };
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type StructuredOutputType = z.infer<z.ZodObject<any, any, any, any>>;

langchain-core/src/language_models/types.ts

@@ -0,0 +1,7 @@
+import { BaseMessageLike } from "../messages/base.js";
+import { type BasePromptValueInterface } from "../prompt_values.js";
+
+export type BaseLanguageModelInput =
+  | BasePromptValueInterface
+  | string
+  | BaseMessageLike[];

langchain-core/src/runnables/base.ts

@@ -20,6 +20,7 @@ import {
   EventStreamCallbackHandlerInput,
   StreamEvent,
   StreamEventData,
+  StreamEventV2,
   isStreamEventsHandler,
 } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
@@ -751,7 +752,8 @@ export abstract class Runnable<
    * chains. Metadata fields have been omitted from the table for brevity.
    * Chain definitions have been included after the table.
    *
-   * **ATTENTION** This reference table is for the V2 version of the schema.
+   * **ATTENTION** This reference table is for the V2 version of the schema (the current default if no
+   * "version" option is passed).
    *
    * ```md
    * +----------------------+-----------------------------+------------------------------------------+
@@ -826,9 +828,7 @@ export abstract class Runnable<
    *  return "Done";
    * });
    *
-   * const eventStream = await slowThing.streamEvents("hello world", {
-   *   version: "v2",
-   * });
+   * const eventStream = await slowThing.streamEvents("hello world");
    *
    * for await (const event of eventStream) {
    *  if (event.event === "on_custom_event") {
@@ -839,38 +839,58 @@ export abstract class Runnable<
    */
   streamEvents(
     input: RunInput,
-    options: Partial<CallOptions> & { version: "v1" | "v2" },
+    options: Partial<CallOptions> & {
+      version?: "v1" | "v2";
+      encoding: "text/event-stream";
+    },
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<Uint8Array>;
+
+  streamEvents(
+    input: RunInput,
+    options: Partial<CallOptions> & {
+      version?: "v2";
+    },
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<StreamEventV2>;
+
+  streamEvents(
+    input: RunInput,
+    options: Partial<CallOptions> & {
+      version: "v1";
+    },
     streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
   ): IterableReadableStream<StreamEvent>;
 
   streamEvents(
     input: RunInput,
     options: Partial<CallOptions> & {
-      version: "v1" | "v2";
-      encoding: "text/event-stream";
+      version?: "v1" | "v2";
+      encoding?: "text/event-stream";
     },
     streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
-  ): IterableReadableStream<Uint8Array>;
+  ): IterableReadableStream<StreamEventV2 | StreamEvent | Uint8Array>;
 
   streamEvents(
     input: RunInput,
     options: Partial<CallOptions> & {
-      version: "v1" | "v2";
-      encoding?: "text/event-stream" | undefined;
+      version?: "v1" | "v2";
+      encoding?: "text/event-stream";
     },
     streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
-  ): IterableReadableStream<StreamEvent | Uint8Array> {
+  ): IterableReadableStream<StreamEventV2 | StreamEvent | Uint8Array> {
     let stream;
-    if (options.version === "v1") {
+    const { version, encoding } = options;
+    if (version === "v1") {
       stream = this._streamEventsV1(input, options, streamOptions);
-    } else if (options.version === "v2") {
+    } else if (version === "v2" || version === undefined) {
       stream = this._streamEventsV2(input, options, streamOptions);
     } else {
       throw new Error(
         `Only versions "v1" and "v2" of the schema are currently supported.`
       );
     }
-    if (options.encoding === "text/event-stream") {
+    if (encoding === "text/event-stream") {
       return convertToHttpEventStream(stream);
     } else {
       return IterableReadableStream.fromAsyncGenerator(stream);
@@ -879,9 +899,9 @@ export abstract class Runnable<
 
   private async *_streamEventsV2(
     input: RunInput,
-    options: Partial<CallOptions> & { version: "v1" | "v2" },
+    options: Partial<CallOptions>,
     streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
-  ): AsyncGenerator<StreamEvent> {
+  ): AsyncGenerator<StreamEventV2> {
     const eventStreamer = new EventStreamCallbackHandler({
       ...streamOptions,
       autoClose: false,
@@ -951,7 +971,7 @@ export abstract class Runnable<
 
   private async *_streamEventsV1(
     input: RunInput,
-    options: Partial<CallOptions> & { version: "v1" | "v2" },
+    options: Partial<CallOptions>,
     streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">
   ): AsyncGenerator<StreamEvent> {
     let runLog;
@@ -1332,29 +1352,49 @@ export class RunnableBinding<
 
   streamEvents(
     input: RunInput,
-    options: Partial<CallOptions> & { version: "v1" | "v2" },
-    streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">
+    options: Partial<CallOptions> & {
+      version?: "v1" | "v2";
+      encoding: "text/event-stream";
+    },
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<Uint8Array>;
+
+  streamEvents(
+    input: RunInput,
+    options: Partial<CallOptions> & {
+      version?: "v2";
+    },
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<StreamEventV2>;
+
+  streamEvents(
+    input: RunInput,
+    options: Partial<CallOptions> & {
+      version: "v1";
+    },
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
   ): IterableReadableStream<StreamEvent>;
 
   streamEvents(
     input: RunInput,
     options: Partial<CallOptions> & {
-      version: "v1" | "v2";
-      encoding: "text/event-stream";
+      version?: "v1" | "v2";
+      encoding?: "text/event-stream";
     },
-    streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">
-  ): IterableReadableStream<Uint8Array>;
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<StreamEventV2 | StreamEvent | Uint8Array>;
 
   streamEvents(
     input: RunInput,
     options: Partial<CallOptions> & {
-      version: "v1" | "v2";
-      encoding?: "text/event-stream" | undefined;
+      version?: "v1" | "v2";
+      encoding?: "text/event-stream";
     },
-    streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">
-  ): IterableReadableStream<StreamEvent | Uint8Array> {
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<StreamEventV2 | StreamEvent | Uint8Array> {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const outerThis = this;
+
     const generator = async function* () {
       yield* outerThis.bound.streamEvents(
         input,

langchain-core/src/runnables/remote.ts

@@ -27,6 +27,10 @@ import {
 import { GenerationChunk, ChatGenerationChunk, RUN_KEY } from "../outputs.js";
 import { convertEventStreamToIterableReadableDataStream } from "../utils/event_source_parse.js";
 import { IterableReadableStream, concat } from "../utils/stream.js";
+import {
+  EventStreamCallbackHandlerInput,
+  StreamEventV2,
+} from "../tracers/event_stream.js";
 
 type RemoteRunnableOptions = {
   timeout?: number;
@@ -597,11 +601,14 @@ export class RemoteRunnable<
 
   _streamEvents(
     input: RunInput,
-    options: Partial<CallOptions> & { version: "v1" | "v2" },
-    streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose"> | undefined
+    config: Partial<CallOptions> & { version?: "v1" | "v2" },
+    streamOptions?:
+      | Omit<EventStreamCallbackHandlerInput, "autoClose">
+      | undefined
   ): AsyncGenerator<StreamEvent> {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const outerThis = this;
+    const options = { version: "v2", ...config };
     const generator = async function* () {
       const [config, kwargs] =
         outerThis._separateRunnableConfigFromCallOptions(options);
@@ -678,27 +685,46 @@ export class RemoteRunnable<
 
   streamEvents(
     input: RunInput,
-    options: Partial<CallOptions> & { version: "v1" | "v2" },
-    streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">
+    options: Partial<CallOptions> & {
+      version?: "v1" | "v2";
+      encoding: "text/event-stream";
+    },
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<Uint8Array>;
+
+  streamEvents(
+    input: RunInput,
+    options: Partial<CallOptions> & {
+      version?: "v2";
+    },
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<StreamEventV2>;
+
+  streamEvents(
+    input: RunInput,
+    options: Partial<CallOptions> & {
+      version: "v1";
+    },
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
   ): IterableReadableStream<StreamEvent>;
 
   streamEvents(
     input: RunInput,
     options: Partial<CallOptions> & {
-      version: "v1" | "v2";
-      encoding: "text/event-stream";
+      version?: "v1" | "v2";
+      encoding?: "text/event-stream";
     },
-    streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">
-  ): IterableReadableStream<Uint8Array>;
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<StreamEventV2 | StreamEvent | Uint8Array>;
 
   streamEvents(
     input: RunInput,
     options: Partial<CallOptions> & {
-      version: "v1" | "v2";
-      encoding?: "text/event-stream" | undefined;
+      version?: "v1" | "v2";
+      encoding?: "text/event-stream";
     },
-    streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">
-  ): IterableReadableStream<StreamEvent | Uint8Array> {
+    streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">
+  ): IterableReadableStream<StreamEventV2 | StreamEvent | Uint8Array> {
     if (options.version !== "v1" && options.version !== "v2") {
       throw new Error(
         `Only versions "v1" and "v2" of the events schema is currently supported.`

langchain-core/src/runnables/tests/runnable_stream_events_v2.test.ts

@@ -1866,6 +1866,88 @@ test("LLM that doesn't support streaming, but is invoked, should emit one on_str
   ]);
 });
 
+test.skip("Test typing", async () => {
+  const tool = new DynamicTool({
+    func: async () => "hello",
+    name: "parameterless",
+    description: "A tool that does nothing",
+  });
+  const events = [];
+  const eventStream = await tool.streamEvents({}, { version: "v2" });
+  for await (const { event, data } of eventStream) {
+    events.push(event);
+    // These shouldn't run, we're just testing type checking
+    if (event === "on_llm_start") {
+      // @ts-expect-error Assert typing is not any
+      void data.input.foo;
+    }
+    if (event === "on_llm_stream") {
+      // @ts-expect-error Assert typing is not any
+      void data.chunk.foo;
+    }
+    if (event === "on_llm_end") {
+      // @ts-expect-error Assert typing is not any
+      void data.output.foo;
+    }
+    if (event === "on_chat_model_start") {
+      // @ts-expect-error Assert typing is not any
+      void data.input.foo;
+    }
+    if (event === "on_chat_model_stream") {
+      // @ts-expect-error Assert typing is not any
+      void data.chunk.foo;
+    }
+    if (event === "on_chat_model_end") {
+      // @ts-expect-error Assert typing is not any
+      void data.output.foo;
+    }
+    if (event === "on_chain_start") {
+      // Typing is any
+      void data.input.foo;
+    }
+    if (event === "on_chain_stream") {
+      // Typing is any
+      void data.chunk.foo;
+    }
+    if (event === "on_chain_end") {
+      // Typing is any
+      void data.output.foo;
+    }
+    if (event === "on_prompt_start") {
+      // Typing is any
+      void data.input.foo;
+    }
+    if (event === "on_prompt_end") {
+      // Typing is any
+      void data.output.foo;
+    }
+    if (event === "on_retriever_start") {
+      // Typing is any
+      void data.input.foo;
+    }
+    if (event === "on_retriever_end") {
+      // Typing is any
+      void data.output.foo;
+    }
+    if (event === "on_tool_start") {
+      // Typing is any
+      void data.input.foo;
+    }
+    if (event === "on_tool_end") {
+      // Typing is any
+      void data.output.foo;
+    }
+    if (event === "on_custom_event") {
+      // Typing is any
+      void data.output.foo;
+    }
+    // @ts-expect-error Invalid event name
+    if (event === "something else") {
+      void 0;
+    }
+  }
+});
+
 test("Runnable streamEvents method with simple tools", async () => {
   const tool = new DynamicTool({
     func: async () => "hello",