@orq-ai/node 4.1.0-rc.0 → 4.1.0-rc.11

package/src/models/components/toolexecutionstartedstreamingevent.ts

@@ -0,0 +1,350 @@
+/*
+ * 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 ToolExecutionStartedStreamingEventType = {
+  EventWorkflowEventsToolExecutionStarted:
+    "event.workflow_events.tool_execution_started",
+} as const;
+export type ToolExecutionStartedStreamingEventType = ClosedEnum<
+  typeof ToolExecutionStartedStreamingEventType
+>;
+
+/**
+ * Orquesta product
+ */
+export const Product = {
+  Remoteconfigs: "remoteconfigs",
+  Deployments: "deployments",
+  Experiments: "experiments",
+  Playgrounds: "playgrounds",
+  Spreadsheets: "spreadsheets",
+  SpreadsheetRun: "spreadsheet_run",
+  LlmEvaluator: "llm_evaluator",
+  Knowledge: "knowledge",
+  Router: "router",
+  Workflows: "workflows",
+  ExternalEvents: "external_events",
+  Agents: "agents",
+  MemoryStores: "memory-stores",
+  Generic: "generic",
+  Evaluators: "evaluators",
+  Otel: "otel",
+} as const;
+/**
+ * Orquesta product
+ */
+export type Product = ClosedEnum<typeof Product>;
+
+export type Memory = {
+  entityId: string;
+};
+
+export type ToolExecutionContext = {
+  actionId: string;
+  agentToolCallId: string;
+  workspaceId: string;
+  agentManifestId: string;
+  agentExecutionId: string;
+  /**
+   * Orquesta product
+   */
+  product: Product;
+  memory?: Memory | undefined;
+  parentId?: string | undefined;
+};
+
+export type ToolExecutionStartedStreamingEventData = {
+  toolId: string;
+  toolKey?: string | undefined;
+  toolDisplayName?: string | undefined;
+  actionType: string;
+  toolArguments: { [k: string]: any };
+  toolExecutionContext: ToolExecutionContext;
+  responseId?: string | undefined;
+  workflowRunId: string;
+};
+
+/**
+ * Emitted when a tool begins execution. Contains the tool ID, name, action type, input arguments, and execution context.
+ */
+export type ToolExecutionStartedStreamingEvent = {
+  type: ToolExecutionStartedStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ToolExecutionStartedStreamingEventData;
+};
+
+/** @internal */
+export const ToolExecutionStartedStreamingEventType$inboundSchema:
+  z.ZodNativeEnum<typeof ToolExecutionStartedStreamingEventType> = z.nativeEnum(
+    ToolExecutionStartedStreamingEventType,
+  );
+/** @internal */
+export const ToolExecutionStartedStreamingEventType$outboundSchema:
+  z.ZodNativeEnum<typeof ToolExecutionStartedStreamingEventType> =
+    ToolExecutionStartedStreamingEventType$inboundSchema;
+
+/** @internal */
+export const Product$inboundSchema: z.ZodNativeEnum<typeof Product> = z
+  .nativeEnum(Product);
+/** @internal */
+export const Product$outboundSchema: z.ZodNativeEnum<typeof Product> =
+  Product$inboundSchema;
+
+/** @internal */
+export const Memory$inboundSchema: z.ZodType<Memory, z.ZodTypeDef, unknown> = z
+  .object({
+    entity_id: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "entity_id": "entityId",
+    });
+  });
+/** @internal */
+export type Memory$Outbound = {
+  entity_id: string;
+};
+
+/** @internal */
+export const Memory$outboundSchema: z.ZodType<
+  Memory$Outbound,
+  z.ZodTypeDef,
+  Memory
+> = z.object({
+  entityId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    entityId: "entity_id",
+  });
+});
+
+export function memoryToJSON(memory: Memory): string {
+  return JSON.stringify(Memory$outboundSchema.parse(memory));
+}
+export function memoryFromJSON(
+  jsonString: string,
+): SafeParseResult<Memory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Memory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Memory' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolExecutionContext$inboundSchema: z.ZodType<
+  ToolExecutionContext,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  action_id: z.string(),
+  agent_tool_call_id: z.string(),
+  workspace_id: z.string(),
+  agent_manifest_id: z.string(),
+  agent_execution_id: z.string(),
+  product: Product$inboundSchema,
+  memory: z.lazy(() => Memory$inboundSchema).optional(),
+  parent_id: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "action_id": "actionId",
+    "agent_tool_call_id": "agentToolCallId",
+    "workspace_id": "workspaceId",
+    "agent_manifest_id": "agentManifestId",
+    "agent_execution_id": "agentExecutionId",
+    "parent_id": "parentId",
+  });
+});
+/** @internal */
+export type ToolExecutionContext$Outbound = {
+  action_id: string;
+  agent_tool_call_id: string;
+  workspace_id: string;
+  agent_manifest_id: string;
+  agent_execution_id: string;
+  product: string;
+  memory?: Memory$Outbound | undefined;
+  parent_id?: string | undefined;
+};
+
+/** @internal */
+export const ToolExecutionContext$outboundSchema: z.ZodType<
+  ToolExecutionContext$Outbound,
+  z.ZodTypeDef,
+  ToolExecutionContext
+> = z.object({
+  actionId: z.string(),
+  agentToolCallId: z.string(),
+  workspaceId: z.string(),
+  agentManifestId: z.string(),
+  agentExecutionId: z.string(),
+  product: Product$outboundSchema,
+  memory: z.lazy(() => Memory$outboundSchema).optional(),
+  parentId: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    actionId: "action_id",
+    agentToolCallId: "agent_tool_call_id",
+    workspaceId: "workspace_id",
+    agentManifestId: "agent_manifest_id",
+    agentExecutionId: "agent_execution_id",
+    parentId: "parent_id",
+  });
+});
+
+export function toolExecutionContextToJSON(
+  toolExecutionContext: ToolExecutionContext,
+): string {
+  return JSON.stringify(
+    ToolExecutionContext$outboundSchema.parse(toolExecutionContext),
+  );
+}
+export function toolExecutionContextFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolExecutionContext, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolExecutionContext$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolExecutionContext' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolExecutionStartedStreamingEventData$inboundSchema: z.ZodType<
+  ToolExecutionStartedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  tool_id: z.string(),
+  tool_key: z.string().optional(),
+  tool_display_name: z.string().optional(),
+  action_type: z.string(),
+  tool_arguments: z.record(z.any()),
+  tool_execution_context: z.lazy(() => ToolExecutionContext$inboundSchema),
+  responseId: z.string().optional(),
+  workflowRunId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_id": "toolId",
+    "tool_key": "toolKey",
+    "tool_display_name": "toolDisplayName",
+    "action_type": "actionType",
+    "tool_arguments": "toolArguments",
+    "tool_execution_context": "toolExecutionContext",
+  });
+});
+/** @internal */
+export type ToolExecutionStartedStreamingEventData$Outbound = {
+  tool_id: string;
+  tool_key?: string | undefined;
+  tool_display_name?: string | undefined;
+  action_type: string;
+  tool_arguments: { [k: string]: any };
+  tool_execution_context: ToolExecutionContext$Outbound;
+  responseId?: string | undefined;
+  workflowRunId: string;
+};
+
+/** @internal */
+export const ToolExecutionStartedStreamingEventData$outboundSchema: z.ZodType<
+  ToolExecutionStartedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ToolExecutionStartedStreamingEventData
+> = z.object({
+  toolId: z.string(),
+  toolKey: z.string().optional(),
+  toolDisplayName: z.string().optional(),
+  actionType: z.string(),
+  toolArguments: z.record(z.any()),
+  toolExecutionContext: z.lazy(() => ToolExecutionContext$outboundSchema),
+  responseId: z.string().optional(),
+  workflowRunId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    toolId: "tool_id",
+    toolKey: "tool_key",
+    toolDisplayName: "tool_display_name",
+    actionType: "action_type",
+    toolArguments: "tool_arguments",
+    toolExecutionContext: "tool_execution_context",
+  });
+});
+
+export function toolExecutionStartedStreamingEventDataToJSON(
+  toolExecutionStartedStreamingEventData:
+    ToolExecutionStartedStreamingEventData,
+): string {
+  return JSON.stringify(
+    ToolExecutionStartedStreamingEventData$outboundSchema.parse(
+      toolExecutionStartedStreamingEventData,
+    ),
+  );
+}
+export function toolExecutionStartedStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolExecutionStartedStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ToolExecutionStartedStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolExecutionStartedStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolExecutionStartedStreamingEvent$inboundSchema: z.ZodType<
+  ToolExecutionStartedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ToolExecutionStartedStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ToolExecutionStartedStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ToolExecutionStartedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ToolExecutionStartedStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ToolExecutionStartedStreamingEvent$outboundSchema: z.ZodType<
+  ToolExecutionStartedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ToolExecutionStartedStreamingEvent
+> = z.object({
+  type: ToolExecutionStartedStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ToolExecutionStartedStreamingEventData$outboundSchema),
+});
+
+export function toolExecutionStartedStreamingEventToJSON(
+  toolExecutionStartedStreamingEvent: ToolExecutionStartedStreamingEvent,
+): string {
+  return JSON.stringify(
+    ToolExecutionStartedStreamingEvent$outboundSchema.parse(
+      toolExecutionStartedStreamingEvent,
+    ),
+  );
+}
+export function toolExecutionStartedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolExecutionStartedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ToolExecutionStartedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolExecutionStartedStreamingEvent' from JSON`,
+  );
+}

package/src/models/components/toolresultpart.ts

@@ -0,0 +1,86 @@
+/*
+ * 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 ToolResultPartKind = {
+  ToolResult: "tool_result",
+} as const;
+export type ToolResultPartKind = ClosedEnum<typeof ToolResultPartKind>;
+
+/**
+ * Tool execution result part. Use this ONLY when providing results for a pending tool call from the agent. The tool_call_id must match the ID from the agent's tool call request.
+ */
+export type ToolResultPart = {
+  kind: ToolResultPartKind;
+  toolCallId: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ToolResultPartKind$inboundSchema: z.ZodNativeEnum<
+  typeof ToolResultPartKind
+> = z.nativeEnum(ToolResultPartKind);
+/** @internal */
+export const ToolResultPartKind$outboundSchema: z.ZodNativeEnum<
+  typeof ToolResultPartKind
+> = ToolResultPartKind$inboundSchema;
+
+/** @internal */
+export const ToolResultPart$inboundSchema: z.ZodType<
+  ToolResultPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ToolResultPartKind$inboundSchema,
+  tool_call_id: z.string(),
+  result: z.any().optional(),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_call_id": "toolCallId",
+  });
+});
+/** @internal */
+export type ToolResultPart$Outbound = {
+  kind: string;
+  tool_call_id: string;
+  result?: any | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ToolResultPart$outboundSchema: z.ZodType<
+  ToolResultPart$Outbound,
+  z.ZodTypeDef,
+  ToolResultPart
+> = z.object({
+  kind: ToolResultPartKind$outboundSchema,
+  toolCallId: z.string(),
+  result: z.any().optional(),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolCallId: "tool_call_id",
+  });
+});
+
+export function toolResultPartToJSON(toolResultPart: ToolResultPart): string {
+  return JSON.stringify(ToolResultPart$outboundSchema.parse(toolResultPart));
+}
+export function toolResultPartFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolResultPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolResultPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolResultPart' from JSON`,
+  );
+}

package/src/models/errors/index.ts

@@ -12,6 +12,7 @@ export * from "./getevals.js";
 export * from "./getpromptversion.js";
 export * from "./honoapierror.js";
 export * from "./httpclienterrors.js";
+export * from "./invokeeval.js";
 export * from "./orqerror.js";
 export * from "./responsevalidationerror.js";
 export * from "./retrieveagentrequest.js";

package/src/models/errors/invokeeval.ts

@@ -0,0 +1,128 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { OrqError } from "./orqerror.js";
+
+/**
+ * Error running the evaluator
+ */
+export type InvokeEvalEvalsResponseBodyData = {
+  message: string;
+};
+
+/**
+ * Error running the evaluator
+ */
+export class InvokeEvalEvalsResponseBody extends OrqError {
+  /** The original data that was passed to this error instance. */
+  data$: InvokeEvalEvalsResponseBodyData;
+
+  constructor(
+    err: InvokeEvalEvalsResponseBodyData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+
+    this.name = "InvokeEvalEvalsResponseBody";
+  }
+}
+
+/**
+ * Workspace ID is not found on the request
+ */
+export type InvokeEvalResponseBodyData = {
+  message: string;
+};
+
+/**
+ * Workspace ID is not found on the request
+ */
+export class InvokeEvalResponseBody extends OrqError {
+  /** The original data that was passed to this error instance. */
+  data$: InvokeEvalResponseBodyData;
+
+  constructor(
+    err: InvokeEvalResponseBodyData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+
+    this.name = "InvokeEvalResponseBody";
+  }
+}
+
+/** @internal */
+export const InvokeEvalEvalsResponseBody$inboundSchema: z.ZodType<
+  InvokeEvalEvalsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new InvokeEvalEvalsResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type InvokeEvalEvalsResponseBody$Outbound = {
+  message: string;
+};
+
+/** @internal */
+export const InvokeEvalEvalsResponseBody$outboundSchema: z.ZodType<
+  InvokeEvalEvalsResponseBody$Outbound,
+  z.ZodTypeDef,
+  InvokeEvalEvalsResponseBody
+> = z.instanceof(InvokeEvalEvalsResponseBody)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    message: z.string(),
+  }));
+
+/** @internal */
+export const InvokeEvalResponseBody$inboundSchema: z.ZodType<
+  InvokeEvalResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new InvokeEvalResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type InvokeEvalResponseBody$Outbound = {
+  message: string;
+};
+
+/** @internal */
+export const InvokeEvalResponseBody$outboundSchema: z.ZodType<
+  InvokeEvalResponseBody$Outbound,
+  z.ZodTypeDef,
+  InvokeEvalResponseBody
+> = z.instanceof(InvokeEvalResponseBody)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    message: z.string(),
+  }));

package/src/models/operations/createagentrequest.ts

@@ -2230,6 +2230,9 @@ export type CreateAgentRequestKnowledgeBases = {
  */
 export type CreateAgentRequestResponseBody = {
   id: string;
+  /**
+   * Unique identifier for the agent within the workspace
+   */
   key: string;
   displayName: string;
   projectId: string;