@orq-ai/node 4.1.0-rc.4 → 4.1.0-rc.7

package/src/models/components/errorstreamingevent.ts

@@ -0,0 +1,129 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const ErrorStreamingEventType = {
+  AgentsError: "agents.error",
+} as const;
+export type ErrorStreamingEventType = ClosedEnum<
+  typeof ErrorStreamingEventType
+>;
+
+export type ErrorStreamingEventData = {
+  error: string;
+  code: string;
+};
+
+/**
+ * Emitted when a streaming error occurs outside of normal agent execution. Contains the error message and error code for debugging.
+ */
+export type ErrorStreamingEvent = {
+  type: ErrorStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ErrorStreamingEventData;
+};
+
+/** @internal */
+export const ErrorStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof ErrorStreamingEventType
+> = z.nativeEnum(ErrorStreamingEventType);
+/** @internal */
+export const ErrorStreamingEventType$outboundSchema: z.ZodNativeEnum<
+  typeof ErrorStreamingEventType
+> = ErrorStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ErrorStreamingEventData$inboundSchema: z.ZodType<
+  ErrorStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.string(),
+  code: z.string(),
+});
+/** @internal */
+export type ErrorStreamingEventData$Outbound = {
+  error: string;
+  code: string;
+};
+
+/** @internal */
+export const ErrorStreamingEventData$outboundSchema: z.ZodType<
+  ErrorStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ErrorStreamingEventData
+> = z.object({
+  error: z.string(),
+  code: z.string(),
+});
+
+export function errorStreamingEventDataToJSON(
+  errorStreamingEventData: ErrorStreamingEventData,
+): string {
+  return JSON.stringify(
+    ErrorStreamingEventData$outboundSchema.parse(errorStreamingEventData),
+  );
+}
+export function errorStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ErrorStreamingEvent$inboundSchema: z.ZodType<
+  ErrorStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ErrorStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ErrorStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ErrorStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ErrorStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ErrorStreamingEvent$outboundSchema: z.ZodType<
+  ErrorStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ErrorStreamingEvent
+> = z.object({
+  type: ErrorStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ErrorStreamingEventData$outboundSchema),
+});
+
+export function errorStreamingEventToJSON(
+  errorStreamingEvent: ErrorStreamingEvent,
+): string {
+  return JSON.stringify(
+    ErrorStreamingEvent$outboundSchema.parse(errorStreamingEvent),
+  );
+}
+export function errorStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/executionnamedstreamingevent.ts

@@ -0,0 +1,142 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const ExecutionNamedStreamingEventType = {
+  EventAgentsExecutionNamed: "event.agents.execution_named",
+} as const;
+export type ExecutionNamedStreamingEventType = ClosedEnum<
+  typeof ExecutionNamedStreamingEventType
+>;
+
+export type ExecutionNamedStreamingEventData = {
+  name: string;
+  agentManifestId: string;
+};
+
+/**
+ * Emitted when the agent execution is assigned a human-readable name, typically generated based on the conversation content.
+ */
+export type ExecutionNamedStreamingEvent = {
+  type: ExecutionNamedStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ExecutionNamedStreamingEventData;
+};
+
+/** @internal */
+export const ExecutionNamedStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof ExecutionNamedStreamingEventType
+> = z.nativeEnum(ExecutionNamedStreamingEventType);
+/** @internal */
+export const ExecutionNamedStreamingEventType$outboundSchema: z.ZodNativeEnum<
+  typeof ExecutionNamedStreamingEventType
+> = ExecutionNamedStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ExecutionNamedStreamingEventData$inboundSchema: z.ZodType<
+  ExecutionNamedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  agent_manifest_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_manifest_id": "agentManifestId",
+  });
+});
+/** @internal */
+export type ExecutionNamedStreamingEventData$Outbound = {
+  name: string;
+  agent_manifest_id: string;
+};
+
+/** @internal */
+export const ExecutionNamedStreamingEventData$outboundSchema: z.ZodType<
+  ExecutionNamedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ExecutionNamedStreamingEventData
+> = z.object({
+  name: z.string(),
+  agentManifestId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    agentManifestId: "agent_manifest_id",
+  });
+});
+
+export function executionNamedStreamingEventDataToJSON(
+  executionNamedStreamingEventData: ExecutionNamedStreamingEventData,
+): string {
+  return JSON.stringify(
+    ExecutionNamedStreamingEventData$outboundSchema.parse(
+      executionNamedStreamingEventData,
+    ),
+  );
+}
+export function executionNamedStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionNamedStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExecutionNamedStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionNamedStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExecutionNamedStreamingEvent$inboundSchema: z.ZodType<
+  ExecutionNamedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ExecutionNamedStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionNamedStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ExecutionNamedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ExecutionNamedStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ExecutionNamedStreamingEvent$outboundSchema: z.ZodType<
+  ExecutionNamedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ExecutionNamedStreamingEvent
+> = z.object({
+  type: ExecutionNamedStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionNamedStreamingEventData$outboundSchema),
+});
+
+export function executionNamedStreamingEventToJSON(
+  executionNamedStreamingEvent: ExecutionNamedStreamingEvent,
+): string {
+  return JSON.stringify(
+    ExecutionNamedStreamingEvent$outboundSchema.parse(
+      executionNamedStreamingEvent,
+    ),
+  );
+}
+export function executionNamedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionNamedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExecutionNamedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionNamedStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/executionreviewedstreamingevent.ts

@@ -0,0 +1,122 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const ExecutionReviewedStreamingEventType = {
+  EventAgentsExecutionReviewed: "event.agents.execution_reviewed",
+} as const;
+export type ExecutionReviewedStreamingEventType = ClosedEnum<
+  typeof ExecutionReviewedStreamingEventType
+>;
+
+export type ExecutionReviewedStreamingEventData = {};
+
+/**
+ * Emitted after the agent execution has been reviewed. The execution will resume processing after this event.
+ */
+export type ExecutionReviewedStreamingEvent = {
+  type: ExecutionReviewedStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ExecutionReviewedStreamingEventData;
+};
+
+/** @internal */
+export const ExecutionReviewedStreamingEventType$inboundSchema: z.ZodNativeEnum<
+  typeof ExecutionReviewedStreamingEventType
+> = z.nativeEnum(ExecutionReviewedStreamingEventType);
+/** @internal */
+export const ExecutionReviewedStreamingEventType$outboundSchema:
+  z.ZodNativeEnum<typeof ExecutionReviewedStreamingEventType> =
+    ExecutionReviewedStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ExecutionReviewedStreamingEventData$inboundSchema: z.ZodType<
+  ExecutionReviewedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ExecutionReviewedStreamingEventData$Outbound = {};
+
+/** @internal */
+export const ExecutionReviewedStreamingEventData$outboundSchema: z.ZodType<
+  ExecutionReviewedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ExecutionReviewedStreamingEventData
+> = z.object({});
+
+export function executionReviewedStreamingEventDataToJSON(
+  executionReviewedStreamingEventData: ExecutionReviewedStreamingEventData,
+): string {
+  return JSON.stringify(
+    ExecutionReviewedStreamingEventData$outboundSchema.parse(
+      executionReviewedStreamingEventData,
+    ),
+  );
+}
+export function executionReviewedStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionReviewedStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ExecutionReviewedStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionReviewedStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExecutionReviewedStreamingEvent$inboundSchema: z.ZodType<
+  ExecutionReviewedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ExecutionReviewedStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionReviewedStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ExecutionReviewedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ExecutionReviewedStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ExecutionReviewedStreamingEvent$outboundSchema: z.ZodType<
+  ExecutionReviewedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ExecutionReviewedStreamingEvent
+> = z.object({
+  type: ExecutionReviewedStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionReviewedStreamingEventData$outboundSchema),
+});
+
+export function executionReviewedStreamingEventToJSON(
+  executionReviewedStreamingEvent: ExecutionReviewedStreamingEvent,
+): string {
+  return JSON.stringify(
+    ExecutionReviewedStreamingEvent$outboundSchema.parse(
+      executionReviewedStreamingEvent,
+    ),
+  );
+}
+export function executionReviewedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionReviewedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExecutionReviewedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionReviewedStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/executionreviewrequiredstreamingevent.ts

@@ -0,0 +1,130 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const ExecutionReviewRequiredStreamingEventType = {
+  EventAgentsExecutionReviewRequired: "event.agents.execution_review_required",
+} as const;
+export type ExecutionReviewRequiredStreamingEventType = ClosedEnum<
+  typeof ExecutionReviewRequiredStreamingEventType
+>;
+
+export type ExecutionReviewRequiredStreamingEventData = {};
+
+/**
+ * Emitted when the entire agent execution requires human review before proceeding. The execution will pause until reviewed.
+ */
+export type ExecutionReviewRequiredStreamingEvent = {
+  type: ExecutionReviewRequiredStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ExecutionReviewRequiredStreamingEventData;
+};
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEventType$inboundSchema:
+  z.ZodNativeEnum<typeof ExecutionReviewRequiredStreamingEventType> = z
+    .nativeEnum(ExecutionReviewRequiredStreamingEventType);
+/** @internal */
+export const ExecutionReviewRequiredStreamingEventType$outboundSchema:
+  z.ZodNativeEnum<typeof ExecutionReviewRequiredStreamingEventType> =
+    ExecutionReviewRequiredStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEventData$inboundSchema: z.ZodType<
+  ExecutionReviewRequiredStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ExecutionReviewRequiredStreamingEventData$Outbound = {};
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEventData$outboundSchema:
+  z.ZodType<
+    ExecutionReviewRequiredStreamingEventData$Outbound,
+    z.ZodTypeDef,
+    ExecutionReviewRequiredStreamingEventData
+  > = z.object({});
+
+export function executionReviewRequiredStreamingEventDataToJSON(
+  executionReviewRequiredStreamingEventData:
+    ExecutionReviewRequiredStreamingEventData,
+): string {
+  return JSON.stringify(
+    ExecutionReviewRequiredStreamingEventData$outboundSchema.parse(
+      executionReviewRequiredStreamingEventData,
+    ),
+  );
+}
+export function executionReviewRequiredStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ExecutionReviewRequiredStreamingEventData,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ExecutionReviewRequiredStreamingEventData$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ExecutionReviewRequiredStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEvent$inboundSchema: z.ZodType<
+  ExecutionReviewRequiredStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ExecutionReviewRequiredStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionReviewRequiredStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ExecutionReviewRequiredStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ExecutionReviewRequiredStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ExecutionReviewRequiredStreamingEvent$outboundSchema: z.ZodType<
+  ExecutionReviewRequiredStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ExecutionReviewRequiredStreamingEvent
+> = z.object({
+  type: ExecutionReviewRequiredStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ExecutionReviewRequiredStreamingEventData$outboundSchema),
+});
+
+export function executionReviewRequiredStreamingEventToJSON(
+  executionReviewRequiredStreamingEvent: ExecutionReviewRequiredStreamingEvent,
+): string {
+  return JSON.stringify(
+    ExecutionReviewRequiredStreamingEvent$outboundSchema.parse(
+      executionReviewRequiredStreamingEvent,
+    ),
+  );
+}
+export function executionReviewRequiredStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ExecutionReviewRequiredStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ExecutionReviewRequiredStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExecutionReviewRequiredStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/filepart.ts

@@ -52,7 +52,7 @@ export type BinaryFormat = {
 export type FileT = BinaryFormat | FileInURIFormat;
 
 /**
- * A file content part that can contain either base64-encoded bytes or a URI reference. Used for images, documents, and other binary content in agent communications.
+ * File attachment part. Use this to send files (images, documents, etc.) to the agent for processing.
  */
 export type FilePart = {
   kind: FilePartKind;

package/src/models/components/index.ts

@@ -2,10 +2,27 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+export * from "./actionreviewedstreamingevent.js";
+export * from "./actionreviewrequestedstreamingevent.js";
+export * from "./agenterroredstreamingevent.js";
+export * from "./agentexecutionstartedstreamingevent.js";
+export * from "./agenthandedoffstreamingevent.js";
+export * from "./agentinactivestreamingevent.js";
+export * from "./agentmessagecreatedstreamingevent.js";
+export * from "./agentstartedstreamingevent.js";
+export * from "./agentthoughtstreamingevent.js";
 export * from "./datapart.js";
+export * from "./errorstreamingevent.js";
+export * from "./executionnamedstreamingevent.js";
+export * from "./executionreviewedstreamingevent.js";
+export * from "./executionreviewrequiredstreamingevent.js";
 export * from "./filepart.js";
 export * from "./invokedeploymentrequest.js";
 export * from "./security.js";
 export * from "./textpart.js";
+export * from "./timeoutstreamingevent.js";
 export * from "./toolcallpart.js";
+export * from "./toolexecutionfailedstreamingevent.js";
+export * from "./toolexecutionfinishedstreamingevent.js";
+export * from "./toolexecutionstartedstreamingevent.js";
 export * from "./toolresultpart.js";

package/src/models/components/invokedeploymentrequest.ts

@@ -170,15 +170,15 @@ export type Audio = {
 /**
  * The type of the tool. Currently, only `function` is supported.
  */
-export const Type = {
+export const PrefixMessagesType = {
   Function: "function",
 } as const;
 /**
  * The type of the tool. Currently, only `function` is supported.
  */
-export type Type = ClosedEnum<typeof Type>;
+export type PrefixMessagesType = ClosedEnum<typeof PrefixMessagesType>;
 
-export type FunctionT = {
+export type PrefixMessagesFunction = {
   /**
    * The name of the function to call.
    */
@@ -197,8 +197,8 @@ export type ToolCalls = {
   /**
    * The type of the tool. Currently, only `function` is supported.
    */
-  type: Type;
-  function: FunctionT;
+  type: PrefixMessagesType;
+  function: PrefixMessagesFunction;
 };
 
 export type AssistantMessage = {
@@ -1954,16 +1954,17 @@ export function audioFromJSON(
 }
 
 /** @internal */
-export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
-  Type,
-);
+export const PrefixMessagesType$inboundSchema: z.ZodNativeEnum<
+  typeof PrefixMessagesType
+> = z.nativeEnum(PrefixMessagesType);
 /** @internal */
-export const Type$outboundSchema: z.ZodNativeEnum<typeof Type> =
-  Type$inboundSchema;
+export const PrefixMessagesType$outboundSchema: z.ZodNativeEnum<
+  typeof PrefixMessagesType
+> = PrefixMessagesType$inboundSchema;
 
 /** @internal */
-export const FunctionT$inboundSchema: z.ZodType<
-  FunctionT,
+export const PrefixMessagesFunction$inboundSchema: z.ZodType<
+  PrefixMessagesFunction,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -1971,31 +1972,35 @@ export const FunctionT$inboundSchema: z.ZodType<
   arguments: z.string().optional(),
 });
 /** @internal */
-export type FunctionT$Outbound = {
+export type PrefixMessagesFunction$Outbound = {
   name?: string | undefined;
   arguments?: string | undefined;
 };
 
 /** @internal */
-export const FunctionT$outboundSchema: z.ZodType<
-  FunctionT$Outbound,
+export const PrefixMessagesFunction$outboundSchema: z.ZodType<
+  PrefixMessagesFunction$Outbound,
   z.ZodTypeDef,
-  FunctionT
+  PrefixMessagesFunction
 > = z.object({
   name: z.string().optional(),
   arguments: z.string().optional(),
 });
 
-export function functionToJSON(functionT: FunctionT): string {
-  return JSON.stringify(FunctionT$outboundSchema.parse(functionT));
+export function prefixMessagesFunctionToJSON(
+  prefixMessagesFunction: PrefixMessagesFunction,
+): string {
+  return JSON.stringify(
+    PrefixMessagesFunction$outboundSchema.parse(prefixMessagesFunction),
+  );
 }
-export function functionFromJSON(
+export function prefixMessagesFunctionFromJSON(
   jsonString: string,
-): SafeParseResult<FunctionT, SDKValidationError> {
+): SafeParseResult<PrefixMessagesFunction, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => FunctionT$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionT' from JSON`,
+    (x) => PrefixMessagesFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PrefixMessagesFunction' from JSON`,
   );
 }
 
@@ -2006,14 +2011,14 @@ export const ToolCalls$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string(),
-  type: Type$inboundSchema,
-  function: z.lazy(() => FunctionT$inboundSchema),
+  type: PrefixMessagesType$inboundSchema,
+  function: z.lazy(() => PrefixMessagesFunction$inboundSchema),
 });
 /** @internal */
 export type ToolCalls$Outbound = {
   id: string;
   type: string;
-  function: FunctionT$Outbound;
+  function: PrefixMessagesFunction$Outbound;
 };
 
 /** @internal */
@@ -2023,8 +2028,8 @@ export const ToolCalls$outboundSchema: z.ZodType<
   ToolCalls
 > = z.object({
   id: z.string(),
-  type: Type$outboundSchema,
-  function: z.lazy(() => FunctionT$outboundSchema),
+  type: PrefixMessagesType$outboundSchema,
+  function: z.lazy(() => PrefixMessagesFunction$outboundSchema),
 });
 
 export function toolCallsToJSON(toolCalls: ToolCalls): string {