syllable-sdk 1.0.13-rc.4 → 1.0.13-rc.6

package/src/models/components/context.ts

@@ -7,36 +7,327 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
-  ContextTask,
-  ContextTask$inboundSchema,
-  ContextTask$Outbound,
-  ContextTask$outboundSchema,
-} from "./contexttask.js";
+  EventTask,
+  EventTask$inboundSchema,
+  EventTask$Outbound,
+  EventTask$outboundSchema,
+} from "./eventtask.js";
+import {
+  ExpressionTask,
+  ExpressionTask$inboundSchema,
+  ExpressionTask$Outbound,
+  ExpressionTask$outboundSchema,
+} from "./expressiontask.js";
+import {
+  LoadToolFromFileTask,
+  LoadToolFromFileTask$inboundSchema,
+  LoadToolFromFileTask$Outbound,
+  LoadToolFromFileTask$outboundSchema,
+} from "./loadtoolfromfiletask.js";
+import {
+  StepsTask,
+  StepsTask$inboundSchema,
+  StepsTask$Outbound,
+  StepsTask$outboundSchema,
+} from "./stepstask.js";
+
+export type Two =
+  | (LoadToolFromFileTask & { type: "import" })
+  | (EventTask & { type: "event" })
+  | (ExpressionTask & { type: "expression" })
+  | (StepsTask & { type: "steps" });
+
+export type Task1 =
+  | (LoadToolFromFileTask & { type: "import" })
+  | (EventTask & { type: "event" })
+  | (ExpressionTask & { type: "expression" })
+  | (StepsTask & { type: "steps" });
 
 /**
  * Task implementation details
  */
-export type Task = ContextTask | Array<ContextTask>;
+export type Task =
+  | (LoadToolFromFileTask & { type: "import" })
+  | (EventTask & { type: "event" })
+  | (ExpressionTask & { type: "expression" })
+  | (StepsTask & { type: "steps" })
+  | Array<
+    | (LoadToolFromFileTask & { type: "import" })
+    | (EventTask & { type: "event" })
+    | (ExpressionTask & { type: "expression" })
+    | (StepsTask & { type: "steps" })
+  >;
 
-/**
- * Context configuration carried alongside a context tool call.
- */
 export type Context = {
   /**
    * Task implementation details
    */
-  task?: ContextTask | Array<ContextTask> | null | undefined;
+  task?:
+    | (LoadToolFromFileTask & { type: "import" })
+    | (EventTask & { type: "event" })
+    | (ExpressionTask & { type: "expression" })
+    | (StepsTask & { type: "steps" })
+    | Array<
+      | (LoadToolFromFileTask & { type: "import" })
+      | (EventTask & { type: "event" })
+      | (ExpressionTask & { type: "expression" })
+      | (StepsTask & { type: "steps" })
+    >
+    | null
+    | undefined;
 };
 
+/** @internal */
+export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z.union(
+  [
+    LoadToolFromFileTask$inboundSchema.and(
+      z.object({ type: z.literal("import") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    EventTask$inboundSchema.and(
+      z.object({ type: z.literal("event") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    ExpressionTask$inboundSchema.and(
+      z.object({ type: z.literal("expression") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    StepsTask$inboundSchema.and(
+      z.object({ type: z.literal("steps") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+  ],
+);
+/** @internal */
+export type Two$Outbound =
+  | (LoadToolFromFileTask$Outbound & { type: "import" })
+  | (EventTask$Outbound & { type: "event" })
+  | (ExpressionTask$Outbound & { type: "expression" })
+  | (StepsTask$Outbound & { type: "steps" });
+
+/** @internal */
+export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = z
+  .union([
+    LoadToolFromFileTask$outboundSchema.and(
+      z.object({ type: z.literal("import") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    EventTask$outboundSchema.and(
+      z.object({ type: z.literal("event") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    ExpressionTask$outboundSchema.and(
+      z.object({ type: z.literal("expression") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    StepsTask$outboundSchema.and(
+      z.object({ type: z.literal("steps") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+  ]);
+
+export function twoToJSON(two: Two): string {
+  return JSON.stringify(Two$outboundSchema.parse(two));
+}
+export function twoFromJSON(
+  jsonString: string,
+): SafeParseResult<Two, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Two$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Two' from JSON`,
+  );
+}
+
+/** @internal */
+export const Task1$inboundSchema: z.ZodType<Task1, z.ZodTypeDef, unknown> = z
+  .union([
+    LoadToolFromFileTask$inboundSchema.and(
+      z.object({ type: z.literal("import") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    EventTask$inboundSchema.and(
+      z.object({ type: z.literal("event") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    ExpressionTask$inboundSchema.and(
+      z.object({ type: z.literal("expression") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    StepsTask$inboundSchema.and(
+      z.object({ type: z.literal("steps") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+  ]);
+/** @internal */
+export type Task1$Outbound =
+  | (LoadToolFromFileTask$Outbound & { type: "import" })
+  | (EventTask$Outbound & { type: "event" })
+  | (ExpressionTask$Outbound & { type: "expression" })
+  | (StepsTask$Outbound & { type: "steps" });
+
+/** @internal */
+export const Task1$outboundSchema: z.ZodType<
+  Task1$Outbound,
+  z.ZodTypeDef,
+  Task1
+> = z.union([
+  LoadToolFromFileTask$outboundSchema.and(
+    z.object({ type: z.literal("import") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  EventTask$outboundSchema.and(
+    z.object({ type: z.literal("event") }).transform((v) => ({ type: v.type })),
+  ),
+  ExpressionTask$outboundSchema.and(
+    z.object({ type: z.literal("expression") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  StepsTask$outboundSchema.and(
+    z.object({ type: z.literal("steps") }).transform((v) => ({ type: v.type })),
+  ),
+]);
+
+export function task1ToJSON(task1: Task1): string {
+  return JSON.stringify(Task1$outboundSchema.parse(task1));
+}
+export function task1FromJSON(
+  jsonString: string,
+): SafeParseResult<Task1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Task1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Task1' from JSON`,
+  );
+}
+
 /** @internal */
 export const Task$inboundSchema: z.ZodType<Task, z.ZodTypeDef, unknown> = z
-  .union([ContextTask$inboundSchema, z.array(ContextTask$inboundSchema)]);
+  .union([
+    z.union([
+      LoadToolFromFileTask$inboundSchema.and(
+        z.object({ type: z.literal("import") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      EventTask$inboundSchema.and(
+        z.object({ type: z.literal("event") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ExpressionTask$inboundSchema.and(
+        z.object({ type: z.literal("expression") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      StepsTask$inboundSchema.and(
+        z.object({ type: z.literal("steps") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+    ]),
+    z.array(
+      z.union([
+        LoadToolFromFileTask$inboundSchema.and(
+          z.object({ type: z.literal("import") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        EventTask$inboundSchema.and(
+          z.object({ type: z.literal("event") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ExpressionTask$inboundSchema.and(
+          z.object({ type: z.literal("expression") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        StepsTask$inboundSchema.and(
+          z.object({ type: z.literal("steps") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+      ]),
+    ),
+  ]);
 /** @internal */
-export type Task$Outbound = ContextTask$Outbound | Array<ContextTask$Outbound>;
+export type Task$Outbound =
+  | (LoadToolFromFileTask$Outbound & { type: "import" })
+  | (EventTask$Outbound & { type: "event" })
+  | (ExpressionTask$Outbound & { type: "expression" })
+  | (StepsTask$Outbound & { type: "steps" })
+  | Array<
+    | (LoadToolFromFileTask$Outbound & { type: "import" })
+    | (EventTask$Outbound & { type: "event" })
+    | (ExpressionTask$Outbound & { type: "expression" })
+    | (StepsTask$Outbound & { type: "steps" })
+  >;
 
 /** @internal */
 export const Task$outboundSchema: z.ZodType<Task$Outbound, z.ZodTypeDef, Task> =
-  z.union([ContextTask$outboundSchema, z.array(ContextTask$outboundSchema)]);
+  z.union([
+    z.union([
+      LoadToolFromFileTask$outboundSchema.and(
+        z.object({ type: z.literal("import") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      EventTask$outboundSchema.and(
+        z.object({ type: z.literal("event") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      ExpressionTask$outboundSchema.and(
+        z.object({ type: z.literal("expression") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+      StepsTask$outboundSchema.and(
+        z.object({ type: z.literal("steps") }).transform((v) => ({
+          type: v.type,
+        })),
+      ),
+    ]),
+    z.array(
+      z.union([
+        LoadToolFromFileTask$outboundSchema.and(
+          z.object({ type: z.literal("import") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        EventTask$outboundSchema.and(
+          z.object({ type: z.literal("event") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ExpressionTask$outboundSchema.and(
+          z.object({ type: z.literal("expression") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        StepsTask$outboundSchema.and(
+          z.object({ type: z.literal("steps") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+      ]),
+    ),
+  ]);
 
 export function taskToJSON(task: Task): string {
   return JSON.stringify(Task$outboundSchema.parse(task));
@@ -55,12 +346,71 @@ export function taskFromJSON(
 export const Context$inboundSchema: z.ZodType<Context, z.ZodTypeDef, unknown> =
   z.object({
     task: z.nullable(
-      z.union([ContextTask$inboundSchema, z.array(ContextTask$inboundSchema)]),
+      z.union([
+        z.union([
+          LoadToolFromFileTask$inboundSchema.and(
+            z.object({ type: z.literal("import") }).transform((v) => ({
+              type: v.type,
+            })),
+          ),
+          EventTask$inboundSchema.and(
+            z.object({ type: z.literal("event") }).transform((v) => ({
+              type: v.type,
+            })),
+          ),
+          ExpressionTask$inboundSchema.and(
+            z.object({ type: z.literal("expression") }).transform((v) => ({
+              type: v.type,
+            })),
+          ),
+          StepsTask$inboundSchema.and(
+            z.object({ type: z.literal("steps") }).transform((v) => ({
+              type: v.type,
+            })),
+          ),
+        ]),
+        z.array(
+          z.union([
+            LoadToolFromFileTask$inboundSchema.and(
+              z.object({ type: z.literal("import") }).transform((v) => ({
+                type: v.type,
+              })),
+            ),
+            EventTask$inboundSchema.and(
+              z.object({ type: z.literal("event") }).transform((v) => ({
+                type: v.type,
+              })),
+            ),
+            ExpressionTask$inboundSchema.and(
+              z.object({ type: z.literal("expression") }).transform((v) => ({
+                type: v.type,
+              })),
+            ),
+            StepsTask$inboundSchema.and(
+              z.object({ type: z.literal("steps") }).transform((v) => ({
+                type: v.type,
+              })),
+            ),
+          ]),
+        ),
+      ]),
     ).optional(),
   });
 /** @internal */
 export type Context$Outbound = {
-  task?: ContextTask$Outbound | Array<ContextTask$Outbound> | null | undefined;
+  task?:
+    | (LoadToolFromFileTask$Outbound & { type: "import" })
+    | (EventTask$Outbound & { type: "event" })
+    | (ExpressionTask$Outbound & { type: "expression" })
+    | (StepsTask$Outbound & { type: "steps" })
+    | Array<
+      | (LoadToolFromFileTask$Outbound & { type: "import" })
+      | (EventTask$Outbound & { type: "event" })
+      | (ExpressionTask$Outbound & { type: "expression" })
+      | (StepsTask$Outbound & { type: "steps" })
+    >
+    | null
+    | undefined;
 };
 
 /** @internal */
@@ -70,7 +420,54 @@ export const Context$outboundSchema: z.ZodType<
   Context
 > = z.object({
   task: z.nullable(
-    z.union([ContextTask$outboundSchema, z.array(ContextTask$outboundSchema)]),
+    z.union([
+      z.union([
+        LoadToolFromFileTask$outboundSchema.and(
+          z.object({ type: z.literal("import") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        EventTask$outboundSchema.and(
+          z.object({ type: z.literal("event") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        ExpressionTask$outboundSchema.and(
+          z.object({ type: z.literal("expression") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        StepsTask$outboundSchema.and(
+          z.object({ type: z.literal("steps") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+      ]),
+      z.array(
+        z.union([
+          LoadToolFromFileTask$outboundSchema.and(
+            z.object({ type: z.literal("import") }).transform((v) => ({
+              type: v.type,
+            })),
+          ),
+          EventTask$outboundSchema.and(
+            z.object({ type: z.literal("event") }).transform((v) => ({
+              type: v.type,
+            })),
+          ),
+          ExpressionTask$outboundSchema.and(
+            z.object({ type: z.literal("expression") }).transform((v) => ({
+              type: v.type,
+            })),
+          ),
+          StepsTask$outboundSchema.and(
+            z.object({ type: z.literal("steps") }).transform((v) => ({
+              type: v.type,
+            })),
+          ),
+        ]),
+      ),
+    ]),
   ).optional(),
 });
 

package/src/models/components/contexttaskmetadata.ts

@@ -0,0 +1,67 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ContextTaskMetadata = {
+  priority?: number | null | undefined;
+  /**
+   * Name of the ToolDefinition that defined this task
+   */
+  parentToolName?: string | null | undefined;
+};
+
+/** @internal */
+export const ContextTaskMetadata$inboundSchema: z.ZodType<
+  ContextTaskMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  priority: z.nullable(z.number().int()).optional(),
+  parent_tool_name: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "parent_tool_name": "parentToolName",
+  });
+});
+/** @internal */
+export type ContextTaskMetadata$Outbound = {
+  priority?: number | null | undefined;
+  parent_tool_name?: string | null | undefined;
+};
+
+/** @internal */
+export const ContextTaskMetadata$outboundSchema: z.ZodType<
+  ContextTaskMetadata$Outbound,
+  z.ZodTypeDef,
+  ContextTaskMetadata
+> = z.object({
+  priority: z.nullable(z.number().int()).optional(),
+  parentToolName: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    parentToolName: "parent_tool_name",
+  });
+});
+
+export function contextTaskMetadataToJSON(
+  contextTaskMetadata: ContextTaskMetadata,
+): string {
+  return JSON.stringify(
+    ContextTaskMetadata$outboundSchema.parse(contextTaskMetadata),
+  );
+}
+export function contextTaskMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<ContextTaskMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContextTaskMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContextTaskMetadata' from JSON`,
+  );
+}

package/src/models/components/contexttoolinfo.ts

@@ -0,0 +1,59 @@
+/*
+ * 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 ContextToolInfo = {
+  /**
+   * The name of the generated tool.
+   */
+  name?: string | null | undefined;
+  /**
+   * The description of the tool.
+   */
+  description?: string | null | undefined;
+};
+
+/** @internal */
+export const ContextToolInfo$inboundSchema: z.ZodType<
+  ContextToolInfo,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.nullable(z.string()).optional(),
+  description: z.nullable(z.string()).optional(),
+});
+/** @internal */
+export type ContextToolInfo$Outbound = {
+  name?: string | null | undefined;
+  description?: string | null | undefined;
+};
+
+/** @internal */
+export const ContextToolInfo$outboundSchema: z.ZodType<
+  ContextToolInfo$Outbound,
+  z.ZodTypeDef,
+  ContextToolInfo
+> = z.object({
+  name: z.nullable(z.string()).optional(),
+  description: z.nullable(z.string()).optional(),
+});
+
+export function contextToolInfoToJSON(
+  contextToolInfo: ContextToolInfo,
+): string {
+  return JSON.stringify(ContextToolInfo$outboundSchema.parse(contextToolInfo));
+}
+export function contextToolInfoFromJSON(
+  jsonString: string,
+): SafeParseResult<ContextToolInfo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContextToolInfo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContextToolInfo' from JSON`,
+  );
+}

package/src/models/components/eventtask.ts

@@ -0,0 +1,102 @@
+/*
+ * 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";
+import {
+  ContextTaskMetadata,
+  ContextTaskMetadata$inboundSchema,
+  ContextTaskMetadata$Outbound,
+  ContextTaskMetadata$outboundSchema,
+} from "./contexttaskmetadata.js";
+import {
+  ContextToolInfo,
+  ContextToolInfo$inboundSchema,
+  ContextToolInfo$Outbound,
+  ContextToolInfo$outboundSchema,
+} from "./contexttoolinfo.js";
+import {
+  EventTaskEvents,
+  EventTaskEvents$inboundSchema,
+  EventTaskEvents$Outbound,
+  EventTaskEvents$outboundSchema,
+} from "./eventtaskevents.js";
+import {
+  Variable,
+  Variable$inboundSchema,
+  Variable$Outbound,
+  Variable$outboundSchema,
+} from "./variable.js";
+
+export type EventTask = {
+  /**
+   * A unique identifier for the task.
+   */
+  id?: string | null | undefined;
+  config?: { [k: string]: any } | null | undefined;
+  variables?: Array<Variable> | null | undefined;
+  metadata?: ContextTaskMetadata | null | undefined;
+  tool?: ContextToolInfo | null | undefined;
+  type?: "event" | undefined;
+  version?: "v1alpha" | undefined;
+  on?: EventTaskEvents | undefined;
+};
+
+/** @internal */
+export const EventTask$inboundSchema: z.ZodType<
+  EventTask,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.nullable(z.string()).optional(),
+  config: z.nullable(z.record(z.any())).optional(),
+  variables: z.nullable(z.array(Variable$inboundSchema)).optional(),
+  metadata: z.nullable(ContextTaskMetadata$inboundSchema).optional(),
+  tool: z.nullable(ContextToolInfo$inboundSchema).optional(),
+  type: z.literal("event").default("event"),
+  version: z.literal("v1alpha").default("v1alpha"),
+  on: EventTaskEvents$inboundSchema.optional(),
+});
+/** @internal */
+export type EventTask$Outbound = {
+  id?: string | null | undefined;
+  config?: { [k: string]: any } | null | undefined;
+  variables?: Array<Variable$Outbound> | null | undefined;
+  metadata?: ContextTaskMetadata$Outbound | null | undefined;
+  tool?: ContextToolInfo$Outbound | null | undefined;
+  type: "event";
+  version: "v1alpha";
+  on?: EventTaskEvents$Outbound | undefined;
+};
+
+/** @internal */
+export const EventTask$outboundSchema: z.ZodType<
+  EventTask$Outbound,
+  z.ZodTypeDef,
+  EventTask
+> = z.object({
+  id: z.nullable(z.string()).optional(),
+  config: z.nullable(z.record(z.any())).optional(),
+  variables: z.nullable(z.array(Variable$outboundSchema)).optional(),
+  metadata: z.nullable(ContextTaskMetadata$outboundSchema).optional(),
+  tool: z.nullable(ContextToolInfo$outboundSchema).optional(),
+  type: z.literal("event").default("event" as const),
+  version: z.literal("v1alpha").default("v1alpha" as const),
+  on: EventTaskEvents$outboundSchema.optional(),
+});
+
+export function eventTaskToJSON(eventTask: EventTask): string {
+  return JSON.stringify(EventTask$outboundSchema.parse(eventTask));
+}
+export function eventTaskFromJSON(
+  jsonString: string,
+): SafeParseResult<EventTask, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventTask$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventTask' from JSON`,
+  );
+}