@orq-ai/node 4.1.0-rc.34 → 4.1.0-rc.35

package/src/mcp-server/tools/conversationsUpdate.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { conversationsUpdate } from "../../funcs/conversationsUpdate.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  requestBody: operations.UpdateConversationRequestBody$inboundSchema,
+  conversationId: z.string(),
+};
+
+export const tool$conversationsUpdate: ToolDefinition<typeof args> = {
+  name: "conversations-update",
+  description: `Update conversation
+
+Modifies an existing conversation's properties. Only the fields provided in the request body will be updated; all other fields remain unchanged. Changes are applied immediately.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await conversationsUpdate(
+      client,
+      args.requestBody,
+      args.conversationId,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/evalsInvoke.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { evalsInvoke } from "../../funcs/evalsInvoke.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.InvokeEvalRequest$inboundSchema,
+};
+
+export const tool$evalsInvoke: ToolDefinition<typeof args> = {
+  name: "evals-invoke",
+  description: `Invoke a Custom Evaluator`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await evalsInvoke(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/models/components/agentexecutionstartedstreamingevent.ts

@@ -8,7 +8,7 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export type Data = {
+export type AgentExecutionStartedStreamingEventData = {
   /**
    * Agent execution task ID (ULID)
    */
@@ -32,53 +32,72 @@ export type AgentExecutionStartedStreamingEvent = {
    * ISO timestamp of the event
    */
   timestamp: string;
-  data: Data;
+  data: AgentExecutionStartedStreamingEventData;
 };
 
 /** @internal */
-export const Data$inboundSchema: z.ZodType<Data, z.ZodTypeDef, unknown> = z
-  .object({
-    agent_task_id: z.string(),
-    workspace_id: z.string(),
-    trace_id: z.string(),
-  }).transform((v) => {
-    return remap$(v, {
-      "agent_task_id": "agentTaskId",
-      "workspace_id": "workspaceId",
-      "trace_id": "traceId",
-    });
+export const AgentExecutionStartedStreamingEventData$inboundSchema: z.ZodType<
+  AgentExecutionStartedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  agent_task_id: z.string(),
+  workspace_id: z.string(),
+  trace_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_task_id": "agentTaskId",
+    "workspace_id": "workspaceId",
+    "trace_id": "traceId",
   });
+});
 /** @internal */
-export type Data$Outbound = {
+export type AgentExecutionStartedStreamingEventData$Outbound = {
   agent_task_id: string;
   workspace_id: string;
   trace_id: string;
 };
 
 /** @internal */
-export const Data$outboundSchema: z.ZodType<Data$Outbound, z.ZodTypeDef, Data> =
-  z.object({
-    agentTaskId: z.string(),
-    workspaceId: z.string(),
-    traceId: z.string(),
-  }).transform((v) => {
-    return remap$(v, {
-      agentTaskId: "agent_task_id",
-      workspaceId: "workspace_id",
-      traceId: "trace_id",
-    });
+export const AgentExecutionStartedStreamingEventData$outboundSchema: z.ZodType<
+  AgentExecutionStartedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  AgentExecutionStartedStreamingEventData
+> = z.object({
+  agentTaskId: z.string(),
+  workspaceId: z.string(),
+  traceId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    agentTaskId: "agent_task_id",
+    workspaceId: "workspace_id",
+    traceId: "trace_id",
   });
+});
 
-export function dataToJSON(data: Data): string {
-  return JSON.stringify(Data$outboundSchema.parse(data));
+export function agentExecutionStartedStreamingEventDataToJSON(
+  agentExecutionStartedStreamingEventData:
+    AgentExecutionStartedStreamingEventData,
+): string {
+  return JSON.stringify(
+    AgentExecutionStartedStreamingEventData$outboundSchema.parse(
+      agentExecutionStartedStreamingEventData,
+    ),
+  );
 }
-export function dataFromJSON(
+export function agentExecutionStartedStreamingEventDataFromJSON(
   jsonString: string,
-): SafeParseResult<Data, SDKValidationError> {
+): SafeParseResult<
+  AgentExecutionStartedStreamingEventData,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => Data$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Data' from JSON`,
+    (x) =>
+      AgentExecutionStartedStreamingEventData$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'AgentExecutionStartedStreamingEventData' from JSON`,
   );
 }
 
@@ -90,13 +109,13 @@ export const AgentExecutionStartedStreamingEvent$inboundSchema: z.ZodType<
 > = z.object({
   type: z.literal("agents.execution_started"),
   timestamp: z.string(),
-  data: z.lazy(() => Data$inboundSchema),
+  data: z.lazy(() => AgentExecutionStartedStreamingEventData$inboundSchema),
 });
 /** @internal */
 export type AgentExecutionStartedStreamingEvent$Outbound = {
   type: "agents.execution_started";
   timestamp: string;
-  data: Data$Outbound;
+  data: AgentExecutionStartedStreamingEventData$Outbound;
 };
 
 /** @internal */
@@ -107,7 +126,7 @@ export const AgentExecutionStartedStreamingEvent$outboundSchema: z.ZodType<
 > = z.object({
   type: z.literal("agents.execution_started"),
   timestamp: z.string(),
-  data: z.lazy(() => Data$outboundSchema),
+  data: z.lazy(() => AgentExecutionStartedStreamingEventData$outboundSchema),
 });
 
 export function agentExecutionStartedStreamingEventToJSON(

package/src/models/components/agentinactivestreamingevent.ts

@@ -78,7 +78,7 @@ export type LastMessageFull = {
 /**
  * The reason why the agent execution became inactive
  */
-export const FinishReason = {
+export const AgentInactiveStreamingEventFinishReason = {
   Stop: "stop",
   Length: "length",
   ToolCalls: "tool_calls",
@@ -90,7 +90,9 @@ export const FinishReason = {
 /**
  * The reason why the agent execution became inactive
  */
-export type FinishReason = ClosedEnum<typeof FinishReason>;
+export type AgentInactiveStreamingEventFinishReason = ClosedEnum<
+  typeof AgentInactiveStreamingEventFinishReason
+>;
 
 export const AgentInactiveStreamingEventDataType = {
   Function: "function",
@@ -99,15 +101,15 @@ export type AgentInactiveStreamingEventDataType = ClosedEnum<
   typeof AgentInactiveStreamingEventDataType
 >;
 
-export type FunctionT = {
+export type AgentInactiveStreamingEventFunction = {
   name?: string | undefined;
   arguments?: string | undefined;
 };
 
-export type PendingToolCalls = {
+export type AgentInactiveStreamingEventPendingToolCalls = {
   id: string;
   type: AgentInactiveStreamingEventDataType;
-  function: FunctionT;
+  function: AgentInactiveStreamingEventFunction;
 };
 
 export type AgentInactiveStreamingEventPromptTokensDetails = {
@@ -164,11 +166,13 @@ export type AgentInactiveStreamingEventData = {
   /**
    * The reason why the agent execution became inactive
    */
-  finishReason: FinishReason;
+  finishReason: AgentInactiveStreamingEventFinishReason;
   /**
    * Tool calls that are pending user response (for function_call finish reason)
    */
-  pendingToolCalls?: Array<PendingToolCalls> | undefined;
+  pendingToolCalls?:
+    | Array<AgentInactiveStreamingEventPendingToolCalls>
+    | undefined;
   /**
    * Token usage from the last agent message
    */
@@ -322,11 +326,13 @@ export function lastMessageFullFromJSON(
 }
 
 /** @internal */
-export const FinishReason$inboundSchema: z.ZodNativeEnum<typeof FinishReason> =
-  z.nativeEnum(FinishReason);
+export const AgentInactiveStreamingEventFinishReason$inboundSchema:
+  z.ZodNativeEnum<typeof AgentInactiveStreamingEventFinishReason> = z
+    .nativeEnum(AgentInactiveStreamingEventFinishReason);
 /** @internal */
-export const FinishReason$outboundSchema: z.ZodNativeEnum<typeof FinishReason> =
-  FinishReason$inboundSchema;
+export const AgentInactiveStreamingEventFinishReason$outboundSchema:
+  z.ZodNativeEnum<typeof AgentInactiveStreamingEventFinishReason> =
+    AgentInactiveStreamingEventFinishReason$inboundSchema;
 
 /** @internal */
 export const AgentInactiveStreamingEventDataType$inboundSchema: z.ZodNativeEnum<
@@ -338,8 +344,8 @@ export const AgentInactiveStreamingEventDataType$outboundSchema:
     AgentInactiveStreamingEventDataType$inboundSchema;
 
 /** @internal */
-export const FunctionT$inboundSchema: z.ZodType<
-  FunctionT,
+export const AgentInactiveStreamingEventFunction$inboundSchema: z.ZodType<
+  AgentInactiveStreamingEventFunction,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -347,76 +353,94 @@ export const FunctionT$inboundSchema: z.ZodType<
   arguments: z.string().optional(),
 });
 /** @internal */
-export type FunctionT$Outbound = {
+export type AgentInactiveStreamingEventFunction$Outbound = {
   name?: string | undefined;
   arguments?: string | undefined;
 };
 
 /** @internal */
-export const FunctionT$outboundSchema: z.ZodType<
-  FunctionT$Outbound,
+export const AgentInactiveStreamingEventFunction$outboundSchema: z.ZodType<
+  AgentInactiveStreamingEventFunction$Outbound,
   z.ZodTypeDef,
-  FunctionT
+  AgentInactiveStreamingEventFunction
 > = 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 agentInactiveStreamingEventFunctionToJSON(
+  agentInactiveStreamingEventFunction: AgentInactiveStreamingEventFunction,
+): string {
+  return JSON.stringify(
+    AgentInactiveStreamingEventFunction$outboundSchema.parse(
+      agentInactiveStreamingEventFunction,
+    ),
+  );
 }
-export function functionFromJSON(
+export function agentInactiveStreamingEventFunctionFromJSON(
   jsonString: string,
-): SafeParseResult<FunctionT, SDKValidationError> {
+): SafeParseResult<AgentInactiveStreamingEventFunction, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => FunctionT$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionT' from JSON`,
+    (x) =>
+      AgentInactiveStreamingEventFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentInactiveStreamingEventFunction' from JSON`,
   );
 }
 
 /** @internal */
-export const PendingToolCalls$inboundSchema: z.ZodType<
-  PendingToolCalls,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  type: AgentInactiveStreamingEventDataType$inboundSchema,
-  function: z.lazy(() => FunctionT$inboundSchema),
-});
+export const AgentInactiveStreamingEventPendingToolCalls$inboundSchema:
+  z.ZodType<
+    AgentInactiveStreamingEventPendingToolCalls,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    id: z.string(),
+    type: AgentInactiveStreamingEventDataType$inboundSchema,
+    function: z.lazy(() => AgentInactiveStreamingEventFunction$inboundSchema),
+  });
 /** @internal */
-export type PendingToolCalls$Outbound = {
+export type AgentInactiveStreamingEventPendingToolCalls$Outbound = {
   id: string;
   type: string;
-  function: FunctionT$Outbound;
+  function: AgentInactiveStreamingEventFunction$Outbound;
 };
 
 /** @internal */
-export const PendingToolCalls$outboundSchema: z.ZodType<
-  PendingToolCalls$Outbound,
-  z.ZodTypeDef,
-  PendingToolCalls
-> = z.object({
-  id: z.string(),
-  type: AgentInactiveStreamingEventDataType$outboundSchema,
-  function: z.lazy(() => FunctionT$outboundSchema),
-});
+export const AgentInactiveStreamingEventPendingToolCalls$outboundSchema:
+  z.ZodType<
+    AgentInactiveStreamingEventPendingToolCalls$Outbound,
+    z.ZodTypeDef,
+    AgentInactiveStreamingEventPendingToolCalls
+  > = z.object({
+    id: z.string(),
+    type: AgentInactiveStreamingEventDataType$outboundSchema,
+    function: z.lazy(() => AgentInactiveStreamingEventFunction$outboundSchema),
+  });
 
-export function pendingToolCallsToJSON(
-  pendingToolCalls: PendingToolCalls,
+export function agentInactiveStreamingEventPendingToolCallsToJSON(
+  agentInactiveStreamingEventPendingToolCalls:
+    AgentInactiveStreamingEventPendingToolCalls,
 ): string {
   return JSON.stringify(
-    PendingToolCalls$outboundSchema.parse(pendingToolCalls),
+    AgentInactiveStreamingEventPendingToolCalls$outboundSchema.parse(
+      agentInactiveStreamingEventPendingToolCalls,
+    ),
   );
 }
-export function pendingToolCallsFromJSON(
+export function agentInactiveStreamingEventPendingToolCallsFromJSON(
   jsonString: string,
-): SafeParseResult<PendingToolCalls, SDKValidationError> {
+): SafeParseResult<
+  AgentInactiveStreamingEventPendingToolCalls,
+  SDKValidationError
+> {
   return safeParse(
     jsonString,
-    (x) => PendingToolCalls$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PendingToolCalls' from JSON`,
+    (x) =>
+      AgentInactiveStreamingEventPendingToolCalls$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'AgentInactiveStreamingEventPendingToolCalls' from JSON`,
   );
 }
 
@@ -656,9 +680,10 @@ export const AgentInactiveStreamingEventData$inboundSchema: z.ZodType<
 > = z.object({
   last_message: z.string(),
   last_message_full: z.lazy(() => LastMessageFull$inboundSchema).optional(),
-  finish_reason: FinishReason$inboundSchema,
-  pending_tool_calls: z.array(z.lazy(() => PendingToolCalls$inboundSchema))
-    .optional(),
+  finish_reason: AgentInactiveStreamingEventFinishReason$inboundSchema,
+  pending_tool_calls: z.array(
+    z.lazy(() => AgentInactiveStreamingEventPendingToolCalls$inboundSchema),
+  ).optional(),
   usage: z.lazy(() => AgentInactiveStreamingEventUsage$inboundSchema)
     .optional(),
   workflowRunId: z.string(),
@@ -676,7 +701,9 @@ export type AgentInactiveStreamingEventData$Outbound = {
   last_message: string;
   last_message_full?: LastMessageFull$Outbound | undefined;
   finish_reason: string;
-  pending_tool_calls?: Array<PendingToolCalls$Outbound> | undefined;
+  pending_tool_calls?:
+    | Array<AgentInactiveStreamingEventPendingToolCalls$Outbound>
+    | undefined;
   usage?: AgentInactiveStreamingEventUsage$Outbound | undefined;
   workflowRunId: string;
   responseId?: string | undefined;
@@ -690,9 +717,10 @@ export const AgentInactiveStreamingEventData$outboundSchema: z.ZodType<
 > = z.object({
   lastMessage: z.string(),
   lastMessageFull: z.lazy(() => LastMessageFull$outboundSchema).optional(),
-  finishReason: FinishReason$outboundSchema,
-  pendingToolCalls: z.array(z.lazy(() => PendingToolCalls$outboundSchema))
-    .optional(),
+  finishReason: AgentInactiveStreamingEventFinishReason$outboundSchema,
+  pendingToolCalls: z.array(
+    z.lazy(() => AgentInactiveStreamingEventPendingToolCalls$outboundSchema),
+  ).optional(),
   usage: z.lazy(() => AgentInactiveStreamingEventUsage$outboundSchema)
     .optional(),
   workflowRunId: z.string(),

package/src/models/components/agentresponsemessage.ts

@@ -0,0 +1,185 @@
+/*
+ * 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";
+import {
+  DataPart,
+  DataPart$inboundSchema,
+  DataPart$Outbound,
+  DataPart$outboundSchema,
+} from "./datapart.js";
+import {
+  FilePart,
+  FilePart$inboundSchema,
+  FilePart$Outbound,
+  FilePart$outboundSchema,
+} from "./filepart.js";
+import {
+  TextPart,
+  TextPart$inboundSchema,
+  TextPart$Outbound,
+  TextPart$outboundSchema,
+} from "./textpart.js";
+import {
+  ToolCallPart,
+  ToolCallPart$inboundSchema,
+  ToolCallPart$Outbound,
+  ToolCallPart$outboundSchema,
+} from "./toolcallpart.js";
+import {
+  ToolResultPart,
+  ToolResultPart$inboundSchema,
+  ToolResultPart$Outbound,
+  ToolResultPart$outboundSchema,
+} from "./toolresultpart.js";
+
+export const Role = {
+  User: "user",
+  Agent: "agent",
+  Tool: "tool",
+  System: "system",
+} as const;
+export type Role = ClosedEnum<typeof Role>;
+
+export type Parts =
+  | TextPart
+  | DataPart
+  | FilePart
+  | ToolCallPart
+  | ToolResultPart;
+
+/**
+ * Response message from an agent execution.
+ */
+export type AgentResponseMessage = {
+  messageId: string;
+  role: Role;
+  parts: Array<TextPart | DataPart | FilePart | ToolCallPart | ToolResultPart>;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const Role$inboundSchema: z.ZodNativeEnum<typeof Role> = z.nativeEnum(
+  Role,
+);
+/** @internal */
+export const Role$outboundSchema: z.ZodNativeEnum<typeof Role> =
+  Role$inboundSchema;
+
+/** @internal */
+export const Parts$inboundSchema: z.ZodType<Parts, z.ZodTypeDef, unknown> = z
+  .union([
+    TextPart$inboundSchema,
+    DataPart$inboundSchema,
+    FilePart$inboundSchema,
+    ToolCallPart$inboundSchema,
+    ToolResultPart$inboundSchema,
+  ]);
+/** @internal */
+export type Parts$Outbound =
+  | TextPart$Outbound
+  | DataPart$Outbound
+  | FilePart$Outbound
+  | ToolCallPart$Outbound
+  | ToolResultPart$Outbound;
+
+/** @internal */
+export const Parts$outboundSchema: z.ZodType<
+  Parts$Outbound,
+  z.ZodTypeDef,
+  Parts
+> = z.union([
+  TextPart$outboundSchema,
+  DataPart$outboundSchema,
+  FilePart$outboundSchema,
+  ToolCallPart$outboundSchema,
+  ToolResultPart$outboundSchema,
+]);
+
+export function partsToJSON(parts: Parts): string {
+  return JSON.stringify(Parts$outboundSchema.parse(parts));
+}
+export function partsFromJSON(
+  jsonString: string,
+): SafeParseResult<Parts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Parts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Parts' from JSON`,
+  );
+}
+
+/** @internal */
+export const AgentResponseMessage$inboundSchema: z.ZodType<
+  AgentResponseMessage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  messageId: z.string(),
+  role: Role$inboundSchema,
+  parts: z.array(
+    z.union([
+      TextPart$inboundSchema,
+      DataPart$inboundSchema,
+      FilePart$inboundSchema,
+      ToolCallPart$inboundSchema,
+      ToolResultPart$inboundSchema,
+    ]),
+  ),
+  metadata: z.record(z.any()).optional(),
+});
+/** @internal */
+export type AgentResponseMessage$Outbound = {
+  messageId: string;
+  role: string;
+  parts: Array<
+    | TextPart$Outbound
+    | DataPart$Outbound
+    | FilePart$Outbound
+    | ToolCallPart$Outbound
+    | ToolResultPart$Outbound
+  >;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const AgentResponseMessage$outboundSchema: z.ZodType<
+  AgentResponseMessage$Outbound,
+  z.ZodTypeDef,
+  AgentResponseMessage
+> = z.object({
+  messageId: z.string(),
+  role: Role$outboundSchema,
+  parts: z.array(
+    z.union([
+      TextPart$outboundSchema,
+      DataPart$outboundSchema,
+      FilePart$outboundSchema,
+      ToolCallPart$outboundSchema,
+      ToolResultPart$outboundSchema,
+    ]),
+  ),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function agentResponseMessageToJSON(
+  agentResponseMessage: AgentResponseMessage,
+): string {
+  return JSON.stringify(
+    AgentResponseMessage$outboundSchema.parse(agentResponseMessage),
+  );
+}
+export function agentResponseMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentResponseMessage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentResponseMessage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentResponseMessage' from JSON`,
+  );
+}