@openrouter/sdk 0.0.0-beta.7 → 0.0.0-beta.8

package/src/models/{chatcompletion.ts → chatresponse.ts}

@@ -6,42 +6,42 @@ import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import {
-  ChatCompletionChoice,
-  ChatCompletionChoice$inboundSchema,
-  ChatCompletionChoice$Outbound,
-  ChatCompletionChoice$outboundSchema,
-} from "./chatcompletionchoice.js";
 import {
   ChatGenerationTokenUsage,
   ChatGenerationTokenUsage$inboundSchema,
   ChatGenerationTokenUsage$Outbound,
   ChatGenerationTokenUsage$outboundSchema,
 } from "./chatgenerationtokenusage.js";
+import {
+  ChatResponseChoice,
+  ChatResponseChoice$inboundSchema,
+  ChatResponseChoice$Outbound,
+  ChatResponseChoice$outboundSchema,
+} from "./chatresponsechoice.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export type ChatCompletion = {
+export type ChatResponse = {
   id: string;
-  choices: Array<ChatCompletionChoice>;
+  choices: Array<ChatResponseChoice>;
   created: number;
   model: string;
   object: "chat.completion";
-  systemFingerprint?: string | undefined;
+  systemFingerprint?: string | null | undefined;
   usage?: ChatGenerationTokenUsage | undefined;
 };
 
 /** @internal */
-export const ChatCompletion$inboundSchema: z.ZodType<
-  ChatCompletion,
+export const ChatResponse$inboundSchema: z.ZodType<
+  ChatResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
   id: z.string(),
-  choices: z.array(ChatCompletionChoice$inboundSchema),
+  choices: z.array(ChatResponseChoice$inboundSchema),
   created: z.number(),
   model: z.string(),
   object: z.literal("chat.completion"),
-  system_fingerprint: z.string().optional(),
+  system_fingerprint: z.nullable(z.string()).optional(),
   usage: ChatGenerationTokenUsage$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -50,28 +50,28 @@ export const ChatCompletion$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type ChatCompletion$Outbound = {
+export type ChatResponse$Outbound = {
   id: string;
-  choices: Array<ChatCompletionChoice$Outbound>;
+  choices: Array<ChatResponseChoice$Outbound>;
   created: number;
   model: string;
   object: "chat.completion";
-  system_fingerprint?: string | undefined;
+  system_fingerprint?: string | null | undefined;
   usage?: ChatGenerationTokenUsage$Outbound | undefined;
 };
 
 /** @internal */
-export const ChatCompletion$outboundSchema: z.ZodType<
-  ChatCompletion$Outbound,
+export const ChatResponse$outboundSchema: z.ZodType<
+  ChatResponse$Outbound,
   z.ZodTypeDef,
-  ChatCompletion
+  ChatResponse
 > = z.object({
   id: z.string(),
-  choices: z.array(ChatCompletionChoice$outboundSchema),
+  choices: z.array(ChatResponseChoice$outboundSchema),
   created: z.number(),
   model: z.string(),
   object: z.literal("chat.completion"),
-  systemFingerprint: z.string().optional(),
+  systemFingerprint: z.nullable(z.string()).optional(),
   usage: ChatGenerationTokenUsage$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -83,25 +83,25 @@ export const ChatCompletion$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ChatCompletion$ {
-  /** @deprecated use `ChatCompletion$inboundSchema` instead. */
-  export const inboundSchema = ChatCompletion$inboundSchema;
-  /** @deprecated use `ChatCompletion$outboundSchema` instead. */
-  export const outboundSchema = ChatCompletion$outboundSchema;
-  /** @deprecated use `ChatCompletion$Outbound` instead. */
-  export type Outbound = ChatCompletion$Outbound;
+export namespace ChatResponse$ {
+  /** @deprecated use `ChatResponse$inboundSchema` instead. */
+  export const inboundSchema = ChatResponse$inboundSchema;
+  /** @deprecated use `ChatResponse$outboundSchema` instead. */
+  export const outboundSchema = ChatResponse$outboundSchema;
+  /** @deprecated use `ChatResponse$Outbound` instead. */
+  export type Outbound = ChatResponse$Outbound;
 }
 
-export function chatCompletionToJSON(chatCompletion: ChatCompletion): string {
-  return JSON.stringify(ChatCompletion$outboundSchema.parse(chatCompletion));
+export function chatResponseToJSON(chatResponse: ChatResponse): string {
+  return JSON.stringify(ChatResponse$outboundSchema.parse(chatResponse));
 }
 
-export function chatCompletionFromJSON(
+export function chatResponseFromJSON(
   jsonString: string,
-): SafeParseResult<ChatCompletion, SDKValidationError> {
+): SafeParseResult<ChatResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ChatCompletion$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ChatCompletion' from JSON`,
+    (x) => ChatResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatResponse' from JSON`,
   );
 }

package/src/models/chatresponsechoice.ts

@@ -0,0 +1,132 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  AssistantMessage,
+  AssistantMessage$inboundSchema,
+  AssistantMessage$Outbound,
+  AssistantMessage$outboundSchema,
+} from "./assistantmessage.js";
+import {
+  ChatMessageTokenLogprobs,
+  ChatMessageTokenLogprobs$inboundSchema,
+  ChatMessageTokenLogprobs$Outbound,
+  ChatMessageTokenLogprobs$outboundSchema,
+} from "./chatmessagetokenlogprobs.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const ChatResponseChoiceFinishReason = {
+  ToolCalls: "tool_calls",
+  Stop: "stop",
+  Length: "length",
+  ContentFilter: "content_filter",
+  Error: "error",
+} as const;
+export type ChatResponseChoiceFinishReason = ClosedEnum<
+  typeof ChatResponseChoiceFinishReason
+>;
+
+export type ChatResponseChoice = {
+  finishReason: ChatResponseChoiceFinishReason | null;
+  index: number;
+  message: AssistantMessage;
+  logprobs?: ChatMessageTokenLogprobs | null | undefined;
+};
+
+/** @internal */
+export const ChatResponseChoiceFinishReason$inboundSchema: z.ZodNativeEnum<
+  typeof ChatResponseChoiceFinishReason
+> = z.nativeEnum(ChatResponseChoiceFinishReason);
+
+/** @internal */
+export const ChatResponseChoiceFinishReason$outboundSchema: z.ZodNativeEnum<
+  typeof ChatResponseChoiceFinishReason
+> = ChatResponseChoiceFinishReason$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatResponseChoiceFinishReason$ {
+  /** @deprecated use `ChatResponseChoiceFinishReason$inboundSchema` instead. */
+  export const inboundSchema = ChatResponseChoiceFinishReason$inboundSchema;
+  /** @deprecated use `ChatResponseChoiceFinishReason$outboundSchema` instead. */
+  export const outboundSchema = ChatResponseChoiceFinishReason$outboundSchema;
+}
+
+/** @internal */
+export const ChatResponseChoice$inboundSchema: z.ZodType<
+  ChatResponseChoice,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  finish_reason: z.nullable(ChatResponseChoiceFinishReason$inboundSchema),
+  index: z.number(),
+  message: AssistantMessage$inboundSchema,
+  logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "finish_reason": "finishReason",
+  });
+});
+
+/** @internal */
+export type ChatResponseChoice$Outbound = {
+  finish_reason: string | null;
+  index: number;
+  message: AssistantMessage$Outbound;
+  logprobs?: ChatMessageTokenLogprobs$Outbound | null | undefined;
+};
+
+/** @internal */
+export const ChatResponseChoice$outboundSchema: z.ZodType<
+  ChatResponseChoice$Outbound,
+  z.ZodTypeDef,
+  ChatResponseChoice
+> = z.object({
+  finishReason: z.nullable(ChatResponseChoiceFinishReason$outboundSchema),
+  index: z.number(),
+  message: AssistantMessage$outboundSchema,
+  logprobs: z.nullable(ChatMessageTokenLogprobs$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    finishReason: "finish_reason",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatResponseChoice$ {
+  /** @deprecated use `ChatResponseChoice$inboundSchema` instead. */
+  export const inboundSchema = ChatResponseChoice$inboundSchema;
+  /** @deprecated use `ChatResponseChoice$outboundSchema` instead. */
+  export const outboundSchema = ChatResponseChoice$outboundSchema;
+  /** @deprecated use `ChatResponseChoice$Outbound` instead. */
+  export type Outbound = ChatResponseChoice$Outbound;
+}
+
+export function chatResponseChoiceToJSON(
+  chatResponseChoice: ChatResponseChoice,
+): string {
+  return JSON.stringify(
+    ChatResponseChoice$outboundSchema.parse(chatResponseChoice),
+  );
+}
+
+export function chatResponseChoiceFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatResponseChoice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatResponseChoice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatResponseChoice' from JSON`,
+  );
+}

package/src/models/chatstreamingchoice.ts

@@ -0,0 +1,132 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  ChatMessageTokenLogprobs,
+  ChatMessageTokenLogprobs$inboundSchema,
+  ChatMessageTokenLogprobs$Outbound,
+  ChatMessageTokenLogprobs$outboundSchema,
+} from "./chatmessagetokenlogprobs.js";
+import {
+  ChatStreamingMessageChunk,
+  ChatStreamingMessageChunk$inboundSchema,
+  ChatStreamingMessageChunk$Outbound,
+  ChatStreamingMessageChunk$outboundSchema,
+} from "./chatstreamingmessagechunk.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const ChatStreamingChoiceFinishReason = {
+  ToolCalls: "tool_calls",
+  Stop: "stop",
+  Length: "length",
+  ContentFilter: "content_filter",
+  Error: "error",
+} as const;
+export type ChatStreamingChoiceFinishReason = ClosedEnum<
+  typeof ChatStreamingChoiceFinishReason
+>;
+
+export type ChatStreamingChoice = {
+  delta: ChatStreamingMessageChunk;
+  finishReason: ChatStreamingChoiceFinishReason | null;
+  index: number;
+  logprobs?: ChatMessageTokenLogprobs | null | undefined;
+};
+
+/** @internal */
+export const ChatStreamingChoiceFinishReason$inboundSchema: z.ZodNativeEnum<
+  typeof ChatStreamingChoiceFinishReason
+> = z.nativeEnum(ChatStreamingChoiceFinishReason);
+
+/** @internal */
+export const ChatStreamingChoiceFinishReason$outboundSchema: z.ZodNativeEnum<
+  typeof ChatStreamingChoiceFinishReason
+> = ChatStreamingChoiceFinishReason$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatStreamingChoiceFinishReason$ {
+  /** @deprecated use `ChatStreamingChoiceFinishReason$inboundSchema` instead. */
+  export const inboundSchema = ChatStreamingChoiceFinishReason$inboundSchema;
+  /** @deprecated use `ChatStreamingChoiceFinishReason$outboundSchema` instead. */
+  export const outboundSchema = ChatStreamingChoiceFinishReason$outboundSchema;
+}
+
+/** @internal */
+export const ChatStreamingChoice$inboundSchema: z.ZodType<
+  ChatStreamingChoice,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  delta: ChatStreamingMessageChunk$inboundSchema,
+  finish_reason: z.nullable(ChatStreamingChoiceFinishReason$inboundSchema),
+  index: z.number(),
+  logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "finish_reason": "finishReason",
+  });
+});
+
+/** @internal */
+export type ChatStreamingChoice$Outbound = {
+  delta: ChatStreamingMessageChunk$Outbound;
+  finish_reason: string | null;
+  index: number;
+  logprobs?: ChatMessageTokenLogprobs$Outbound | null | undefined;
+};
+
+/** @internal */
+export const ChatStreamingChoice$outboundSchema: z.ZodType<
+  ChatStreamingChoice$Outbound,
+  z.ZodTypeDef,
+  ChatStreamingChoice
+> = z.object({
+  delta: ChatStreamingMessageChunk$outboundSchema,
+  finishReason: z.nullable(ChatStreamingChoiceFinishReason$outboundSchema),
+  index: z.number(),
+  logprobs: z.nullable(ChatMessageTokenLogprobs$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    finishReason: "finish_reason",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatStreamingChoice$ {
+  /** @deprecated use `ChatStreamingChoice$inboundSchema` instead. */
+  export const inboundSchema = ChatStreamingChoice$inboundSchema;
+  /** @deprecated use `ChatStreamingChoice$outboundSchema` instead. */
+  export const outboundSchema = ChatStreamingChoice$outboundSchema;
+  /** @deprecated use `ChatStreamingChoice$Outbound` instead. */
+  export type Outbound = ChatStreamingChoice$Outbound;
+}
+
+export function chatStreamingChoiceToJSON(
+  chatStreamingChoice: ChatStreamingChoice,
+): string {
+  return JSON.stringify(
+    ChatStreamingChoice$outboundSchema.parse(chatStreamingChoice),
+  );
+}
+
+export function chatStreamingChoiceFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatStreamingChoice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatStreamingChoice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatStreamingChoice' from JSON`,
+  );
+}

package/src/models/{chatcompletionchunkchoicedelta.ts → chatstreamingmessagechunk.ts}

@@ -8,11 +8,11 @@ import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import {
-  ChatCompletionChunkChoiceDeltaToolCall,
-  ChatCompletionChunkChoiceDeltaToolCall$inboundSchema,
-  ChatCompletionChunkChoiceDeltaToolCall$Outbound,
-  ChatCompletionChunkChoiceDeltaToolCall$outboundSchema,
-} from "./chatcompletionchunkchoicedeltatoolcall.js";
+  ChatStreamingMessageToolCall,
+  ChatStreamingMessageToolCall$inboundSchema,
+  ChatStreamingMessageToolCall$Outbound,
+  ChatStreamingMessageToolCall$outboundSchema,
+} from "./chatstreamingmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export const Role = {
@@ -20,12 +20,12 @@ export const Role = {
 } as const;
 export type Role = ClosedEnum<typeof Role>;
 
-export type ChatCompletionChunkChoiceDelta = {
+export type ChatStreamingMessageChunk = {
   role?: Role | undefined;
   content?: string | null | undefined;
   reasoning?: string | null | undefined;
   refusal?: string | null | undefined;
-  toolCalls?: Array<ChatCompletionChunkChoiceDeltaToolCall> | undefined;
+  toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
 };
 
 /** @internal */
@@ -49,8 +49,8 @@ export namespace Role$ {
 }
 
 /** @internal */
-export const ChatCompletionChunkChoiceDelta$inboundSchema: z.ZodType<
-  ChatCompletionChunkChoiceDelta,
+export const ChatStreamingMessageChunk$inboundSchema: z.ZodType<
+  ChatStreamingMessageChunk,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -58,8 +58,7 @@ export const ChatCompletionChunkChoiceDelta$inboundSchema: z.ZodType<
   content: z.nullable(z.string()).optional(),
   reasoning: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),
-  tool_calls: z.array(ChatCompletionChunkChoiceDeltaToolCall$inboundSchema)
-    .optional(),
+  tool_calls: z.array(ChatStreamingMessageToolCall$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "tool_calls": "toolCalls",
@@ -67,28 +66,25 @@ export const ChatCompletionChunkChoiceDelta$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type ChatCompletionChunkChoiceDelta$Outbound = {
+export type ChatStreamingMessageChunk$Outbound = {
   role?: string | undefined;
   content?: string | null | undefined;
   reasoning?: string | null | undefined;
   refusal?: string | null | undefined;
-  tool_calls?:
-    | Array<ChatCompletionChunkChoiceDeltaToolCall$Outbound>
-    | undefined;
+  tool_calls?: Array<ChatStreamingMessageToolCall$Outbound> | undefined;
 };
 
 /** @internal */
-export const ChatCompletionChunkChoiceDelta$outboundSchema: z.ZodType<
-  ChatCompletionChunkChoiceDelta$Outbound,
+export const ChatStreamingMessageChunk$outboundSchema: z.ZodType<
+  ChatStreamingMessageChunk$Outbound,
   z.ZodTypeDef,
-  ChatCompletionChunkChoiceDelta
+  ChatStreamingMessageChunk
 > = z.object({
   role: Role$outboundSchema.optional(),
   content: z.nullable(z.string()).optional(),
   reasoning: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),
-  toolCalls: z.array(ChatCompletionChunkChoiceDeltaToolCall$outboundSchema)
-    .optional(),
+  toolCalls: z.array(ChatStreamingMessageToolCall$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     toolCalls: "tool_calls",
@@ -99,31 +95,29 @@ export const ChatCompletionChunkChoiceDelta$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ChatCompletionChunkChoiceDelta$ {
-  /** @deprecated use `ChatCompletionChunkChoiceDelta$inboundSchema` instead. */
-  export const inboundSchema = ChatCompletionChunkChoiceDelta$inboundSchema;
-  /** @deprecated use `ChatCompletionChunkChoiceDelta$outboundSchema` instead. */
-  export const outboundSchema = ChatCompletionChunkChoiceDelta$outboundSchema;
-  /** @deprecated use `ChatCompletionChunkChoiceDelta$Outbound` instead. */
-  export type Outbound = ChatCompletionChunkChoiceDelta$Outbound;
+export namespace ChatStreamingMessageChunk$ {
+  /** @deprecated use `ChatStreamingMessageChunk$inboundSchema` instead. */
+  export const inboundSchema = ChatStreamingMessageChunk$inboundSchema;
+  /** @deprecated use `ChatStreamingMessageChunk$outboundSchema` instead. */
+  export const outboundSchema = ChatStreamingMessageChunk$outboundSchema;
+  /** @deprecated use `ChatStreamingMessageChunk$Outbound` instead. */
+  export type Outbound = ChatStreamingMessageChunk$Outbound;
 }
 
-export function chatCompletionChunkChoiceDeltaToJSON(
-  chatCompletionChunkChoiceDelta: ChatCompletionChunkChoiceDelta,
+export function chatStreamingMessageChunkToJSON(
+  chatStreamingMessageChunk: ChatStreamingMessageChunk,
 ): string {
   return JSON.stringify(
-    ChatCompletionChunkChoiceDelta$outboundSchema.parse(
-      chatCompletionChunkChoiceDelta,
-    ),
+    ChatStreamingMessageChunk$outboundSchema.parse(chatStreamingMessageChunk),
   );
 }
 
-export function chatCompletionChunkChoiceDeltaFromJSON(
+export function chatStreamingMessageChunkFromJSON(
   jsonString: string,
-): SafeParseResult<ChatCompletionChunkChoiceDelta, SDKValidationError> {
+): SafeParseResult<ChatStreamingMessageChunk, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ChatCompletionChunkChoiceDelta$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ChatCompletionChunkChoiceDelta' from JSON`,
+    (x) => ChatStreamingMessageChunk$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatStreamingMessageChunk' from JSON`,
   );
 }

package/src/models/chatstreamingmessagetoolcall.ts

@@ -0,0 +1,149 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ChatStreamingMessageToolCallFunction = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+export type ChatStreamingMessageToolCall = {
+  index: number;
+  id?: string | undefined;
+  type?: "function" | undefined;
+  function?: ChatStreamingMessageToolCallFunction | undefined;
+};
+
+/** @internal */
+export const ChatStreamingMessageToolCallFunction$inboundSchema: z.ZodType<
+  ChatStreamingMessageToolCallFunction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+
+/** @internal */
+export type ChatStreamingMessageToolCallFunction$Outbound = {
+  name?: string | undefined;
+  arguments?: string | undefined;
+};
+
+/** @internal */
+export const ChatStreamingMessageToolCallFunction$outboundSchema: z.ZodType<
+  ChatStreamingMessageToolCallFunction$Outbound,
+  z.ZodTypeDef,
+  ChatStreamingMessageToolCallFunction
+> = z.object({
+  name: z.string().optional(),
+  arguments: z.string().optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatStreamingMessageToolCallFunction$ {
+  /** @deprecated use `ChatStreamingMessageToolCallFunction$inboundSchema` instead. */
+  export const inboundSchema =
+    ChatStreamingMessageToolCallFunction$inboundSchema;
+  /** @deprecated use `ChatStreamingMessageToolCallFunction$outboundSchema` instead. */
+  export const outboundSchema =
+    ChatStreamingMessageToolCallFunction$outboundSchema;
+  /** @deprecated use `ChatStreamingMessageToolCallFunction$Outbound` instead. */
+  export type Outbound = ChatStreamingMessageToolCallFunction$Outbound;
+}
+
+export function chatStreamingMessageToolCallFunctionToJSON(
+  chatStreamingMessageToolCallFunction: ChatStreamingMessageToolCallFunction,
+): string {
+  return JSON.stringify(
+    ChatStreamingMessageToolCallFunction$outboundSchema.parse(
+      chatStreamingMessageToolCallFunction,
+    ),
+  );
+}
+
+export function chatStreamingMessageToolCallFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatStreamingMessageToolCallFunction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ChatStreamingMessageToolCallFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatStreamingMessageToolCallFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const ChatStreamingMessageToolCall$inboundSchema: z.ZodType<
+  ChatStreamingMessageToolCall,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  index: z.number(),
+  id: z.string().optional(),
+  type: z.literal("function").optional(),
+  function: z.lazy(() => ChatStreamingMessageToolCallFunction$inboundSchema)
+    .optional(),
+});
+
+/** @internal */
+export type ChatStreamingMessageToolCall$Outbound = {
+  index: number;
+  id?: string | undefined;
+  type?: "function" | undefined;
+  function?: ChatStreamingMessageToolCallFunction$Outbound | undefined;
+};
+
+/** @internal */
+export const ChatStreamingMessageToolCall$outboundSchema: z.ZodType<
+  ChatStreamingMessageToolCall$Outbound,
+  z.ZodTypeDef,
+  ChatStreamingMessageToolCall
+> = z.object({
+  index: z.number(),
+  id: z.string().optional(),
+  type: z.literal("function").optional(),
+  function: z.lazy(() => ChatStreamingMessageToolCallFunction$outboundSchema)
+    .optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatStreamingMessageToolCall$ {
+  /** @deprecated use `ChatStreamingMessageToolCall$inboundSchema` instead. */
+  export const inboundSchema = ChatStreamingMessageToolCall$inboundSchema;
+  /** @deprecated use `ChatStreamingMessageToolCall$outboundSchema` instead. */
+  export const outboundSchema = ChatStreamingMessageToolCall$outboundSchema;
+  /** @deprecated use `ChatStreamingMessageToolCall$Outbound` instead. */
+  export type Outbound = ChatStreamingMessageToolCall$Outbound;
+}
+
+export function chatStreamingMessageToolCallToJSON(
+  chatStreamingMessageToolCall: ChatStreamingMessageToolCall,
+): string {
+  return JSON.stringify(
+    ChatStreamingMessageToolCall$outboundSchema.parse(
+      chatStreamingMessageToolCall,
+    ),
+  );
+}
+
+export function chatStreamingMessageToolCallFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatStreamingMessageToolCall, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatStreamingMessageToolCall$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatStreamingMessageToolCall' from JSON`,
+  );
+}