@orq-ai/node 4.1.0-rc.3 → 4.1.0-rc.5

package/src/models/components/toolcallpart.ts

@@ -0,0 +1,92 @@
+/*
+ * 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 ToolCallPartKind = {
+  ToolCall: "tool_call",
+} as const;
+export type ToolCallPartKind = ClosedEnum<typeof ToolCallPartKind>;
+
+/**
+ * A tool invocation request from an agent. Contains the tool name, unique call ID, and arguments for the tool execution.
+ */
+export type ToolCallPart = {
+  kind: ToolCallPartKind;
+  toolName: string;
+  toolCallId: string;
+  arguments: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ToolCallPartKind$inboundSchema: z.ZodNativeEnum<
+  typeof ToolCallPartKind
+> = z.nativeEnum(ToolCallPartKind);
+/** @internal */
+export const ToolCallPartKind$outboundSchema: z.ZodNativeEnum<
+  typeof ToolCallPartKind
+> = ToolCallPartKind$inboundSchema;
+
+/** @internal */
+export const ToolCallPart$inboundSchema: z.ZodType<
+  ToolCallPart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: ToolCallPartKind$inboundSchema,
+  tool_name: z.string(),
+  tool_call_id: z.string(),
+  arguments: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_name": "toolName",
+    "tool_call_id": "toolCallId",
+  });
+});
+/** @internal */
+export type ToolCallPart$Outbound = {
+  kind: string;
+  tool_name: string;
+  tool_call_id: string;
+  arguments: { [k: string]: any };
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ToolCallPart$outboundSchema: z.ZodType<
+  ToolCallPart$Outbound,
+  z.ZodTypeDef,
+  ToolCallPart
+> = z.object({
+  kind: ToolCallPartKind$outboundSchema,
+  toolName: z.string(),
+  toolCallId: z.string(),
+  arguments: z.record(z.any()),
+  metadata: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    toolName: "tool_name",
+    toolCallId: "tool_call_id",
+  });
+});
+
+export function toolCallPartToJSON(toolCallPart: ToolCallPart): string {
+  return JSON.stringify(ToolCallPart$outboundSchema.parse(toolCallPart));
+}
+export function toolCallPartFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolCallPart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolCallPart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolCallPart' from JSON`,
+  );
+}

package/src/models/components/toolexecutionfailedstreamingevent.ts

@@ -0,0 +1,406 @@
+/*
+ * 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 ToolExecutionFailedStreamingEventType = {
+  EventWorkflowEventsToolExecutionFailed:
+    "event.workflow_events.tool_execution_failed",
+} as const;
+export type ToolExecutionFailedStreamingEventType = ClosedEnum<
+  typeof ToolExecutionFailedStreamingEventType
+>;
+
+export type ErrorT = {
+  message: string;
+  stack?: string | undefined;
+};
+
+/**
+ * Orquesta product
+ */
+export const ToolExecutionFailedStreamingEventProduct = {
+  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 ToolExecutionFailedStreamingEventProduct = ClosedEnum<
+  typeof ToolExecutionFailedStreamingEventProduct
+>;
+
+export type ToolExecutionFailedStreamingEventMemory = {
+  entityId: string;
+};
+
+export type ToolExecutionFailedStreamingEventToolExecutionContext = {
+  actionId: string;
+  agentToolCallId: string;
+  workspaceId: string;
+  agentManifestId: string;
+  agentExecutionId: string;
+  /**
+   * Orquesta product
+   */
+  product: ToolExecutionFailedStreamingEventProduct;
+  memory?: ToolExecutionFailedStreamingEventMemory | undefined;
+  parentId?: string | undefined;
+};
+
+export type ToolExecutionFailedStreamingEventData = {
+  error: ErrorT;
+  actionType: string;
+  toolExecutionContext: ToolExecutionFailedStreamingEventToolExecutionContext;
+  responseId?: string | undefined;
+  workflowRunId: string;
+};
+
+/**
+ * Emitted when a tool execution fails. Contains the error details, action type, and execution context.
+ */
+export type ToolExecutionFailedStreamingEvent = {
+  type: ToolExecutionFailedStreamingEventType;
+  /**
+   * ISO timestamp of the event
+   */
+  timestamp: string;
+  data: ToolExecutionFailedStreamingEventData;
+};
+
+/** @internal */
+export const ToolExecutionFailedStreamingEventType$inboundSchema:
+  z.ZodNativeEnum<typeof ToolExecutionFailedStreamingEventType> = z.nativeEnum(
+    ToolExecutionFailedStreamingEventType,
+  );
+/** @internal */
+export const ToolExecutionFailedStreamingEventType$outboundSchema:
+  z.ZodNativeEnum<typeof ToolExecutionFailedStreamingEventType> =
+    ToolExecutionFailedStreamingEventType$inboundSchema;
+
+/** @internal */
+export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
+  .object({
+    message: z.string(),
+    stack: z.string().optional(),
+  });
+/** @internal */
+export type ErrorT$Outbound = {
+  message: string;
+  stack?: string | undefined;
+};
+
+/** @internal */
+export const ErrorT$outboundSchema: z.ZodType<
+  ErrorT$Outbound,
+  z.ZodTypeDef,
+  ErrorT
+> = z.object({
+  message: z.string(),
+  stack: z.string().optional(),
+});
+
+export function errorToJSON(errorT: ErrorT): string {
+  return JSON.stringify(ErrorT$outboundSchema.parse(errorT));
+}
+export function errorFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolExecutionFailedStreamingEventProduct$inboundSchema:
+  z.ZodNativeEnum<typeof ToolExecutionFailedStreamingEventProduct> = z
+    .nativeEnum(ToolExecutionFailedStreamingEventProduct);
+/** @internal */
+export const ToolExecutionFailedStreamingEventProduct$outboundSchema:
+  z.ZodNativeEnum<typeof ToolExecutionFailedStreamingEventProduct> =
+    ToolExecutionFailedStreamingEventProduct$inboundSchema;
+
+/** @internal */
+export const ToolExecutionFailedStreamingEventMemory$inboundSchema: z.ZodType<
+  ToolExecutionFailedStreamingEventMemory,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  entity_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "entity_id": "entityId",
+  });
+});
+/** @internal */
+export type ToolExecutionFailedStreamingEventMemory$Outbound = {
+  entity_id: string;
+};
+
+/** @internal */
+export const ToolExecutionFailedStreamingEventMemory$outboundSchema: z.ZodType<
+  ToolExecutionFailedStreamingEventMemory$Outbound,
+  z.ZodTypeDef,
+  ToolExecutionFailedStreamingEventMemory
+> = z.object({
+  entityId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    entityId: "entity_id",
+  });
+});
+
+export function toolExecutionFailedStreamingEventMemoryToJSON(
+  toolExecutionFailedStreamingEventMemory:
+    ToolExecutionFailedStreamingEventMemory,
+): string {
+  return JSON.stringify(
+    ToolExecutionFailedStreamingEventMemory$outboundSchema.parse(
+      toolExecutionFailedStreamingEventMemory,
+    ),
+  );
+}
+export function toolExecutionFailedStreamingEventMemoryFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ToolExecutionFailedStreamingEventMemory,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ToolExecutionFailedStreamingEventMemory$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ToolExecutionFailedStreamingEventMemory' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolExecutionFailedStreamingEventToolExecutionContext$inboundSchema:
+  z.ZodType<
+    ToolExecutionFailedStreamingEventToolExecutionContext,
+    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: ToolExecutionFailedStreamingEventProduct$inboundSchema,
+    memory: z.lazy(() => ToolExecutionFailedStreamingEventMemory$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 ToolExecutionFailedStreamingEventToolExecutionContext$Outbound = {
+  action_id: string;
+  agent_tool_call_id: string;
+  workspace_id: string;
+  agent_manifest_id: string;
+  agent_execution_id: string;
+  product: string;
+  memory?: ToolExecutionFailedStreamingEventMemory$Outbound | undefined;
+  parent_id?: string | undefined;
+};
+
+/** @internal */
+export const ToolExecutionFailedStreamingEventToolExecutionContext$outboundSchema:
+  z.ZodType<
+    ToolExecutionFailedStreamingEventToolExecutionContext$Outbound,
+    z.ZodTypeDef,
+    ToolExecutionFailedStreamingEventToolExecutionContext
+  > = z.object({
+    actionId: z.string(),
+    agentToolCallId: z.string(),
+    workspaceId: z.string(),
+    agentManifestId: z.string(),
+    agentExecutionId: z.string(),
+    product: ToolExecutionFailedStreamingEventProduct$outboundSchema,
+    memory: z.lazy(() => ToolExecutionFailedStreamingEventMemory$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 toolExecutionFailedStreamingEventToolExecutionContextToJSON(
+  toolExecutionFailedStreamingEventToolExecutionContext:
+    ToolExecutionFailedStreamingEventToolExecutionContext,
+): string {
+  return JSON.stringify(
+    ToolExecutionFailedStreamingEventToolExecutionContext$outboundSchema.parse(
+      toolExecutionFailedStreamingEventToolExecutionContext,
+    ),
+  );
+}
+export function toolExecutionFailedStreamingEventToolExecutionContextFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ToolExecutionFailedStreamingEventToolExecutionContext,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ToolExecutionFailedStreamingEventToolExecutionContext$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ToolExecutionFailedStreamingEventToolExecutionContext' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolExecutionFailedStreamingEventData$inboundSchema: z.ZodType<
+  ToolExecutionFailedStreamingEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.lazy(() => ErrorT$inboundSchema),
+  action_type: z.string(),
+  tool_execution_context: z.lazy(() =>
+    ToolExecutionFailedStreamingEventToolExecutionContext$inboundSchema
+  ),
+  responseId: z.string().optional(),
+  workflowRunId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "action_type": "actionType",
+    "tool_execution_context": "toolExecutionContext",
+  });
+});
+/** @internal */
+export type ToolExecutionFailedStreamingEventData$Outbound = {
+  error: ErrorT$Outbound;
+  action_type: string;
+  tool_execution_context:
+    ToolExecutionFailedStreamingEventToolExecutionContext$Outbound;
+  responseId?: string | undefined;
+  workflowRunId: string;
+};
+
+/** @internal */
+export const ToolExecutionFailedStreamingEventData$outboundSchema: z.ZodType<
+  ToolExecutionFailedStreamingEventData$Outbound,
+  z.ZodTypeDef,
+  ToolExecutionFailedStreamingEventData
+> = z.object({
+  error: z.lazy(() => ErrorT$outboundSchema),
+  actionType: z.string(),
+  toolExecutionContext: z.lazy(() =>
+    ToolExecutionFailedStreamingEventToolExecutionContext$outboundSchema
+  ),
+  responseId: z.string().optional(),
+  workflowRunId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    actionType: "action_type",
+    toolExecutionContext: "tool_execution_context",
+  });
+});
+
+export function toolExecutionFailedStreamingEventDataToJSON(
+  toolExecutionFailedStreamingEventData: ToolExecutionFailedStreamingEventData,
+): string {
+  return JSON.stringify(
+    ToolExecutionFailedStreamingEventData$outboundSchema.parse(
+      toolExecutionFailedStreamingEventData,
+    ),
+  );
+}
+export function toolExecutionFailedStreamingEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolExecutionFailedStreamingEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ToolExecutionFailedStreamingEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolExecutionFailedStreamingEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ToolExecutionFailedStreamingEvent$inboundSchema: z.ZodType<
+  ToolExecutionFailedStreamingEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: ToolExecutionFailedStreamingEventType$inboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ToolExecutionFailedStreamingEventData$inboundSchema),
+});
+/** @internal */
+export type ToolExecutionFailedStreamingEvent$Outbound = {
+  type: string;
+  timestamp: string;
+  data: ToolExecutionFailedStreamingEventData$Outbound;
+};
+
+/** @internal */
+export const ToolExecutionFailedStreamingEvent$outboundSchema: z.ZodType<
+  ToolExecutionFailedStreamingEvent$Outbound,
+  z.ZodTypeDef,
+  ToolExecutionFailedStreamingEvent
+> = z.object({
+  type: ToolExecutionFailedStreamingEventType$outboundSchema,
+  timestamp: z.string(),
+  data: z.lazy(() => ToolExecutionFailedStreamingEventData$outboundSchema),
+});
+
+export function toolExecutionFailedStreamingEventToJSON(
+  toolExecutionFailedStreamingEvent: ToolExecutionFailedStreamingEvent,
+): string {
+  return JSON.stringify(
+    ToolExecutionFailedStreamingEvent$outboundSchema.parse(
+      toolExecutionFailedStreamingEvent,
+    ),
+  );
+}
+export function toolExecutionFailedStreamingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolExecutionFailedStreamingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolExecutionFailedStreamingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolExecutionFailedStreamingEvent' from JSON`,
+  );
+}