@orq-ai/node 4.14.0 → 4.14.3

package/packages/orq-rc/src/models/components/agentresponserequest.ts

@@ -29,29 +29,29 @@ import {
 /**
  * Message containing tool execution results
  */
-export const RoleToolMessage = {
+export const ToolMessage = {
   Tool: "tool",
 } as const;
 /**
  * Message containing tool execution results
  */
-export type RoleToolMessage = ClosedEnum<typeof RoleToolMessage>;
+export type ToolMessage = ClosedEnum<typeof ToolMessage>;
 
 /**
  * Message from the end user
  */
-export const RoleUserMessage = {
+export const UserMessage = {
   User: "user",
 } as const;
 /**
  * Message from the end user
  */
-export type RoleUserMessage = ClosedEnum<typeof RoleUserMessage>;
+export type UserMessage = ClosedEnum<typeof UserMessage>;
 
 /**
  * Message role (user or tool for continuing executions)
  */
-export type AgentResponseRequestRole = RoleUserMessage | RoleToolMessage;
+export type AgentResponseRequestRole = UserMessage | ToolMessage;
 
 /**
  * Message part that can be provided by users. Use "text" for regular messages, "file" for attachments, or "tool_result" when responding to tool call requests.
@@ -73,7 +73,7 @@ export type A2AMessage = {
   /**
    * Message role (user or tool for continuing executions)
    */
-  role: RoleUserMessage | RoleToolMessage;
+  role: UserMessage | ToolMessage;
   /**
    * A2A message parts (text, file, or tool_result only). Note: Tool role messages must only contain tool_result parts.
    */
@@ -145,7 +145,7 @@ export type Contact = {
 /**
  * Thread information to group related requests
  */
-export type AgentResponseRequestThread = {
+export type Thread = {
   /**
    * Unique thread identifier to group related invocations.
    */
@@ -228,7 +228,7 @@ export type AgentResponseRequest = {
   /**
    * Thread information to group related requests
    */
-  thread?: AgentResponseRequestThread | undefined;
+  thread?: Thread | undefined;
   /**
    * Memory configuration for the agent execution. Used to associate memory stores with specific entities like users or sessions.
    */
@@ -260,14 +260,12 @@ export type AgentResponseRequest = {
 };
 
 /** @internal */
-export const RoleToolMessage$outboundSchema: z.ZodNativeEnum<
-  typeof RoleToolMessage
-> = z.nativeEnum(RoleToolMessage);
+export const ToolMessage$outboundSchema: z.ZodNativeEnum<typeof ToolMessage> = z
+  .nativeEnum(ToolMessage);
 
 /** @internal */
-export const RoleUserMessage$outboundSchema: z.ZodNativeEnum<
-  typeof RoleUserMessage
-> = z.nativeEnum(RoleUserMessage);
+export const UserMessage$outboundSchema: z.ZodNativeEnum<typeof UserMessage> = z
+  .nativeEnum(UserMessage);
 
 /** @internal */
 export type AgentResponseRequestRole$Outbound = string | string;
@@ -277,7 +275,7 @@ export const AgentResponseRequestRole$outboundSchema: z.ZodType<
   AgentResponseRequestRole$Outbound,
   z.ZodTypeDef,
   AgentResponseRequestRole
-> = z.union([RoleUserMessage$outboundSchema, RoleToolMessage$outboundSchema]);
+> = z.union([UserMessage$outboundSchema, ToolMessage$outboundSchema]);
 
 export function agentResponseRequestRoleToJSON(
   agentResponseRequestRole: AgentResponseRequestRole,
@@ -333,10 +331,7 @@ export const A2AMessage$outboundSchema: z.ZodType<
   A2AMessage
 > = z.object({
   messageId: z.string().optional(),
-  role: z.union([
-    RoleUserMessage$outboundSchema,
-    RoleToolMessage$outboundSchema,
-  ]),
+  role: z.union([UserMessage$outboundSchema, ToolMessage$outboundSchema]),
   parts: z.array(
     z.union([
       TextPart$outboundSchema,
@@ -424,27 +419,23 @@ export function contactToJSON(contact: Contact): string {
 }
 
 /** @internal */
-export type AgentResponseRequestThread$Outbound = {
+export type Thread$Outbound = {
   id: string;
   tags?: Array<string> | undefined;
 };
 
 /** @internal */
-export const AgentResponseRequestThread$outboundSchema: z.ZodType<
-  AgentResponseRequestThread$Outbound,
+export const Thread$outboundSchema: z.ZodType<
+  Thread$Outbound,
   z.ZodTypeDef,
-  AgentResponseRequestThread
+  Thread
 > = z.object({
   id: z.string(),
   tags: z.array(z.string()).optional(),
 });
 
-export function agentResponseRequestThreadToJSON(
-  agentResponseRequestThread: AgentResponseRequestThread,
-): string {
-  return JSON.stringify(
-    AgentResponseRequestThread$outboundSchema.parse(agentResponseRequestThread),
-  );
+export function threadToJSON(thread: Thread): string {
+  return JSON.stringify(Thread$outboundSchema.parse(thread));
 }
 
 /** @internal */
@@ -524,7 +515,7 @@ export type AgentResponseRequest$Outbound = {
   variables?: { [k: string]: any } | undefined;
   identity?: AgentResponseRequestIdentity$Outbound | undefined;
   contact?: Contact$Outbound | undefined;
-  thread?: AgentResponseRequestThread$Outbound | undefined;
+  thread?: Thread$Outbound | undefined;
   memory?: AgentResponseRequestMemory$Outbound | undefined;
   metadata?: { [k: string]: any } | undefined;
   engine?: string | undefined;
@@ -546,7 +537,7 @@ export const AgentResponseRequest$outboundSchema: z.ZodType<
   identity: z.lazy(() => AgentResponseRequestIdentity$outboundSchema)
     .optional(),
   contact: z.lazy(() => Contact$outboundSchema).optional(),
-  thread: z.lazy(() => AgentResponseRequestThread$outboundSchema).optional(),
+  thread: z.lazy(() => Thread$outboundSchema).optional(),
   memory: z.lazy(() => AgentResponseRequestMemory$outboundSchema).optional(),
   metadata: z.record(z.any()).optional(),
   engine: Engine$outboundSchema.optional(),

package/packages/orq-rc/src/models/components/agentthoughtstreamingevent.ts

@@ -83,7 +83,7 @@ export type AgentThoughtStreamingEventFunction = {
   arguments?: string | undefined;
 };
 
-export type AgentThoughtStreamingEventToolCalls = {
+export type ToolCalls = {
   index?: number | undefined;
   id?: string | undefined;
   type?: AgentThoughtStreamingEventDataType | undefined;
@@ -104,7 +104,7 @@ export type AgentThoughtStreamingEventDataRole = ClosedEnum<
 /**
  * If the audio output modality is requested, this object contains data about the audio response from the model.
  */
-export type AgentThoughtStreamingEventAudio = {
+export type Audio = {
   id: string;
   expiresAt: number;
   data: string;
@@ -117,7 +117,7 @@ export type AgentThoughtStreamingEventAudio = {
 export type AgentThoughtStreamingEventMessage = {
   content?: string | null | undefined;
   refusal?: string | null | undefined;
-  toolCalls?: Array<AgentThoughtStreamingEventToolCalls> | undefined;
+  toolCalls?: Array<ToolCalls> | undefined;
   role?: AgentThoughtStreamingEventDataRole | undefined;
   /**
    * Internal thought process of the model
@@ -134,7 +134,7 @@ export type AgentThoughtStreamingEventMessage = {
   /**
    * If the audio output modality is requested, this object contains data about the audio response from the model.
    */
-  audio?: AgentThoughtStreamingEventAudio | null | undefined;
+  audio?: Audio | null | undefined;
 };
 
 export type TopLogprobs = {
@@ -152,7 +152,7 @@ export type TopLogprobs = {
   bytes: Array<number> | null;
 };
 
-export type AgentThoughtStreamingEventContent = {
+export type Content = {
   /**
    * The token.
    */
@@ -212,7 +212,7 @@ export type Logprobs = {
   /**
    * A list of message content tokens with log probability information.
    */
-  content: Array<AgentThoughtStreamingEventContent> | null;
+  content: Array<Content> | null;
   /**
    * A list of message refusal tokens with log probability information.
    */
@@ -411,8 +411,8 @@ export function agentThoughtStreamingEventFunctionFromJSON(
 }
 
 /** @internal */
-export const AgentThoughtStreamingEventToolCalls$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventToolCalls,
+export const ToolCalls$inboundSchema: z.ZodType<
+  ToolCalls,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -428,14 +428,13 @@ export const AgentThoughtStreamingEventToolCalls$inboundSchema: z.ZodType<
   });
 });
 
-export function agentThoughtStreamingEventToolCallsFromJSON(
+export function toolCallsFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventToolCalls, SDKValidationError> {
+): SafeParseResult<ToolCalls, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) =>
-      AgentThoughtStreamingEventToolCalls$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventToolCalls' from JSON`,
+    (x) => ToolCalls$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolCalls' from JSON`,
   );
 }
 
@@ -445,28 +444,25 @@ export const AgentThoughtStreamingEventDataRole$inboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(AgentThoughtStreamingEventDataRole);
 
 /** @internal */
-export const AgentThoughtStreamingEventAudio$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventAudio,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  expires_at: z.number().int(),
-  data: z.string(),
-  transcript: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "expires_at": "expiresAt",
+export const Audio$inboundSchema: z.ZodType<Audio, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    expires_at: z.number().int(),
+    data: z.string(),
+    transcript: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "expires_at": "expiresAt",
+    });
   });
-});
 
-export function agentThoughtStreamingEventAudioFromJSON(
+export function audioFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventAudio, SDKValidationError> {
+): SafeParseResult<Audio, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AgentThoughtStreamingEventAudio$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventAudio' from JSON`,
+    (x) => Audio$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Audio' from JSON`,
   );
 }
 
@@ -478,15 +474,12 @@ export const AgentThoughtStreamingEventMessage$inboundSchema: z.ZodType<
 > = z.object({
   content: z.nullable(z.string()).optional(),
   refusal: z.nullable(z.string()).optional(),
-  tool_calls: z.array(
-    z.lazy(() => AgentThoughtStreamingEventToolCalls$inboundSchema),
-  ).optional(),
+  tool_calls: z.array(z.lazy(() => ToolCalls$inboundSchema)).optional(),
   role: AgentThoughtStreamingEventDataRole$inboundSchema.optional(),
   reasoning: z.nullable(z.string()).optional(),
   reasoning_signature: z.nullable(z.string()).optional(),
   redacted_reasoning: z.string().optional(),
-  audio: z.nullable(z.lazy(() => AgentThoughtStreamingEventAudio$inboundSchema))
-    .optional(),
+  audio: z.nullable(z.lazy(() => Audio$inboundSchema)).optional(),
 }).transform((v) => {
   return remap$(v, {
     "tool_calls": "toolCalls",
@@ -527,28 +520,25 @@ export function topLogprobsFromJSON(
 }
 
 /** @internal */
-export const AgentThoughtStreamingEventContent$inboundSchema: z.ZodType<
-  AgentThoughtStreamingEventContent,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  token: z.string(),
-  logprob: z.number(),
-  bytes: z.nullable(z.array(z.number())),
-  top_logprobs: z.array(z.lazy(() => TopLogprobs$inboundSchema)),
-}).transform((v) => {
-  return remap$(v, {
-    "top_logprobs": "topLogprobs",
+export const Content$inboundSchema: z.ZodType<Content, z.ZodTypeDef, unknown> =
+  z.object({
+    token: z.string(),
+    logprob: z.number(),
+    bytes: z.nullable(z.array(z.number())),
+    top_logprobs: z.array(z.lazy(() => TopLogprobs$inboundSchema)),
+  }).transform((v) => {
+    return remap$(v, {
+      "top_logprobs": "topLogprobs",
+    });
   });
-});
 
-export function agentThoughtStreamingEventContentFromJSON(
+export function contentFromJSON(
   jsonString: string,
-): SafeParseResult<AgentThoughtStreamingEventContent, SDKValidationError> {
+): SafeParseResult<Content, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AgentThoughtStreamingEventContent$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AgentThoughtStreamingEventContent' from JSON`,
+    (x) => Content$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Content' from JSON`,
   );
 }
 
@@ -605,9 +595,7 @@ export const Logprobs$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  content: z.nullable(
-    z.array(z.lazy(() => AgentThoughtStreamingEventContent$inboundSchema)),
-  ),
+  content: z.nullable(z.array(z.lazy(() => Content$inboundSchema))),
   refusal: z.nullable(z.array(z.lazy(() => Refusal$inboundSchema))),
 });
 

package/packages/orq-rc/src/models/components/agenttoolinputcrud.ts

@@ -33,6 +33,11 @@ import {
   DeleteMemoryDocumentToolInput$Outbound,
   DeleteMemoryDocumentToolInput$outboundSchema,
 } from "./deletememorydocumenttoolinput.js";
+import {
+  FileSystemToolInput,
+  FileSystemToolInput$Outbound,
+  FileSystemToolInput$outboundSchema,
+} from "./filesystemtoolinput.js";
 import {
   FunctionToolInput,
   FunctionToolInput$Outbound,
@@ -117,6 +122,7 @@ export type AgentToolInputCRUD =
   | AdvisorToolInput
   | SidekickToolInput
   | CodeInterpreterToolInput
+  | FileSystemToolInput
   | HttpToolInput
   | CodeToolInput
   | FunctionToolInput
@@ -139,6 +145,7 @@ export type AgentToolInputCRUD$Outbound =
   | AdvisorToolInput$Outbound
   | SidekickToolInput$Outbound
   | CodeInterpreterToolInput$Outbound
+  | FileSystemToolInput$Outbound
   | HttpToolInput$Outbound
   | CodeToolInput$Outbound
   | FunctionToolInput$Outbound
@@ -165,6 +172,7 @@ export const AgentToolInputCRUD$outboundSchema: z.ZodType<
   AdvisorToolInput$outboundSchema,
   SidekickToolInput$outboundSchema,
   CodeInterpreterToolInput$outboundSchema,
+  FileSystemToolInput$outboundSchema,
   HttpToolInput$outboundSchema,
   CodeToolInput$outboundSchema,
   FunctionToolInput$outboundSchema,

package/packages/orq-rc/src/models/components/createfilesystemfolderrequest.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type CreateFileSystemFolderRequest = {
+  /**
+   * Folder to create, relative to the file system root
+   */
+  path: string;
+};
+
+/** @internal */
+export type CreateFileSystemFolderRequest$Outbound = {
+  path: string;
+};
+
+/** @internal */
+export const CreateFileSystemFolderRequest$outboundSchema: z.ZodType<
+  CreateFileSystemFolderRequest$Outbound,
+  z.ZodTypeDef,
+  CreateFileSystemFolderRequest
+> = z.object({
+  path: z.string(),
+});
+
+export function createFileSystemFolderRequestToJSON(
+  createFileSystemFolderRequest: CreateFileSystemFolderRequest,
+): string {
+  return JSON.stringify(
+    CreateFileSystemFolderRequest$outboundSchema.parse(
+      createFileSystemFolderRequest,
+    ),
+  );
+}

package/packages/orq-rc/src/models/components/createfilesystemfolderresponse.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CreateFileSystemFolderResponse = {
+  path: string;
+};
+
+/** @internal */
+export const CreateFileSystemFolderResponse$inboundSchema: z.ZodType<
+  CreateFileSystemFolderResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  path: z.string(),
+});
+
+export function createFileSystemFolderResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateFileSystemFolderResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateFileSystemFolderResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateFileSystemFolderResponse' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/createfilesystemrequest.ts

@@ -0,0 +1,94 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import {
+  Sharing,
+  Sharing$Outbound,
+  Sharing$outboundSchema,
+} from "./sharing.js";
+
+/**
+ * Whether external MCP clients may reach this file system. Defaults to disabled.
+ */
+export const ExternalAccess = {
+  Disabled: "disabled",
+  ReadOnly: "read_only",
+  ReadWrite: "read_write",
+} as const;
+/**
+ * Whether external MCP clients may reach this file system. Defaults to disabled.
+ */
+export type ExternalAccess = ClosedEnum<typeof ExternalAccess>;
+
+export type CreateFileSystemRequest = {
+  /**
+   * The unique key of the file system. The key is unique and immutable and cannot be repeated within the same workspace.
+   */
+  key: string;
+  /**
+   * Entity storage path. With workspace-level API keys, the first element identifies the project. With project-level API keys, the path is relative to that project.
+   */
+  path: string;
+  /**
+   * Human readable name shown in the UI. Defaults to the key.
+   */
+  displayName?: string | undefined;
+  description?: string | undefined;
+  /**
+   * Whether external MCP clients may reach this file system. Defaults to disabled.
+   */
+  externalAccess?: ExternalAccess | undefined;
+  /**
+   * Sharing controls which projects in the workspace may use this entity and
+   *
+   * @remarks
+   *  what they may do with it.
+   */
+  sharing?: Sharing | undefined;
+};
+
+/** @internal */
+export const ExternalAccess$outboundSchema: z.ZodNativeEnum<
+  typeof ExternalAccess
+> = z.nativeEnum(ExternalAccess);
+
+/** @internal */
+export type CreateFileSystemRequest$Outbound = {
+  key: string;
+  path: string;
+  display_name?: string | undefined;
+  description?: string | undefined;
+  external_access?: string | undefined;
+  sharing?: Sharing$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateFileSystemRequest$outboundSchema: z.ZodType<
+  CreateFileSystemRequest$Outbound,
+  z.ZodTypeDef,
+  CreateFileSystemRequest
+> = z.object({
+  key: z.string(),
+  path: z.string(),
+  displayName: z.string().optional(),
+  description: z.string().optional(),
+  externalAccess: ExternalAccess$outboundSchema.optional(),
+  sharing: Sharing$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    externalAccess: "external_access",
+  });
+});
+
+export function createFileSystemRequestToJSON(
+  createFileSystemRequest: CreateFileSystemRequest,
+): string {
+  return JSON.stringify(
+    CreateFileSystemRequest$outboundSchema.parse(createFileSystemRequest),
+  );
+}

package/packages/orq-rc/src/models/components/deletefilesystemfileresponse.ts

@@ -0,0 +1,49 @@
+/*
+ * 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 DeleteFileSystemFileResponseType = {
+  File: "file",
+  Dir: "dir",
+  Symlink: "symlink",
+  Other: "other",
+} as const;
+export type DeleteFileSystemFileResponseType = ClosedEnum<
+  typeof DeleteFileSystemFileResponseType
+>;
+
+export type DeleteFileSystemFileResponse = {
+  path: string;
+  type: DeleteFileSystemFileResponseType;
+};
+
+/** @internal */
+export const DeleteFileSystemFileResponseType$inboundSchema: z.ZodNativeEnum<
+  typeof DeleteFileSystemFileResponseType
+> = z.nativeEnum(DeleteFileSystemFileResponseType);
+
+/** @internal */
+export const DeleteFileSystemFileResponse$inboundSchema: z.ZodType<
+  DeleteFileSystemFileResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  path: z.string(),
+  type: DeleteFileSystemFileResponseType$inboundSchema,
+});
+
+export function deleteFileSystemFileResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteFileSystemFileResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteFileSystemFileResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteFileSystemFileResponse' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/deletefilesystemresponse.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DeleteFileSystemResponse = {};
+
+/** @internal */
+export const DeleteFileSystemResponse$inboundSchema: z.ZodType<
+  DeleteFileSystemResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function deleteFileSystemResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteFileSystemResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteFileSystemResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteFileSystemResponse' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/evaluationcontext.ts

@@ -14,7 +14,7 @@ import {
   StructuredOutput$outboundSchema,
 } from "./structuredoutput.js";
 
-export type EvaluationContextMessages = {};
+export type Messages = {};
 
 /**
  * The data to grade. When `messages` is present it is the conversation and
@@ -24,7 +24,7 @@ export type EvaluationContextMessages = {};
  *  conversation carries no assistant turn. Mirrors graders-api buildGraderRequest.
  */
 export type EvaluationContext = {
-  messages?: Array<EvaluationContextMessages> | undefined;
+  messages?: Array<Messages> | undefined;
   /**
    * StructuredInput names its fields after the template variables they feed, so
    *
@@ -37,26 +37,22 @@ export type EvaluationContext = {
 };
 
 /** @internal */
-export type EvaluationContextMessages$Outbound = {};
+export type Messages$Outbound = {};
 
 /** @internal */
-export const EvaluationContextMessages$outboundSchema: z.ZodType<
-  EvaluationContextMessages$Outbound,
+export const Messages$outboundSchema: z.ZodType<
+  Messages$Outbound,
   z.ZodTypeDef,
-  EvaluationContextMessages
+  Messages
 > = z.object({});
 
-export function evaluationContextMessagesToJSON(
-  evaluationContextMessages: EvaluationContextMessages,
-): string {
-  return JSON.stringify(
-    EvaluationContextMessages$outboundSchema.parse(evaluationContextMessages),
-  );
+export function messagesToJSON(messages: Messages): string {
+  return JSON.stringify(Messages$outboundSchema.parse(messages));
 }
 
 /** @internal */
 export type EvaluationContext$Outbound = {
-  messages?: Array<EvaluationContextMessages$Outbound> | undefined;
+  messages?: Array<Messages$Outbound> | undefined;
   input?: StructuredInput$Outbound | undefined;
   output?: StructuredOutput$Outbound | undefined;
   variables?: { [k: string]: any } | undefined;
@@ -68,8 +64,7 @@ export const EvaluationContext$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EvaluationContext
 > = z.object({
-  messages: z.array(z.lazy(() => EvaluationContextMessages$outboundSchema))
-    .optional(),
+  messages: z.array(z.lazy(() => Messages$outboundSchema)).optional(),
   input: StructuredInput$outboundSchema.optional(),
   output: StructuredOutput$outboundSchema.optional(),
   variables: z.record(z.any()).optional(),