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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syllable-sdk",
-  "version": "1.0.13-rc.4",
+  "version": "1.0.13-rc.6",
   "author": "Syllable",
   "bin": {
     "mcp": "bin/mcp-server.js"

package/src/lib/config.ts

@@ -61,7 +61,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.0.2",
-  sdkVersion: "1.0.13-rc.4",
+  sdkVersion: "1.0.13-rc.6",
   genVersion: "2.760.2",
-  userAgent: "speakeasy-sdk/typescript 1.0.13-rc.4 2.760.2 0.0.2 syllable-sdk",
+  userAgent: "speakeasy-sdk/typescript 1.0.13-rc.6 2.760.2 0.0.2 syllable-sdk",
 } as const;

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

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "1.0.13-rc.4",
+    currentVersion: "1.0.13-rc.6",
   },
 });
 

package/src/mcp-server/server.ts

@@ -183,7 +183,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "SyllableSDK",
-    version: "1.0.13-rc.4",
+    version: "1.0.13-rc.6",
   });
 
   const client = new SyllableSDKCore({

package/src/models/components/bodyinsightsfolderuploadfile.ts

@@ -8,37 +8,40 @@ import { blobLikeSchema } from "../../types/blobs.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export type FileT = {
+export type BodyInsightsFolderUploadFileFile = {
   fileName: string;
   content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
 };
 
 export type BodyInsightsFolderUploadFile = {
-  file?: FileT | Blob | undefined;
+  file?: BodyInsightsFolderUploadFileFile | Blob | undefined;
 };
 
 /** @internal */
-export const FileT$inboundSchema: z.ZodType<FileT, z.ZodTypeDef, unknown> = z
-  .object({
-    fileName: z.string(),
-    content: z.union([
-      z.instanceof(ReadableStream<Uint8Array>),
-      z.instanceof(Blob),
-      z.instanceof(ArrayBuffer),
-      z.instanceof(Uint8Array),
-    ]),
-  });
+export const BodyInsightsFolderUploadFileFile$inboundSchema: z.ZodType<
+  BodyInsightsFolderUploadFileFile,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  fileName: z.string(),
+  content: z.union([
+    z.instanceof(ReadableStream<Uint8Array>),
+    z.instanceof(Blob),
+    z.instanceof(ArrayBuffer),
+    z.instanceof(Uint8Array),
+  ]),
+});
 /** @internal */
-export type FileT$Outbound = {
+export type BodyInsightsFolderUploadFileFile$Outbound = {
   fileName: string;
   content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
 };
 
 /** @internal */
-export const FileT$outboundSchema: z.ZodType<
-  FileT$Outbound,
+export const BodyInsightsFolderUploadFileFile$outboundSchema: z.ZodType<
+  BodyInsightsFolderUploadFileFile$Outbound,
   z.ZodTypeDef,
-  FileT
+  BodyInsightsFolderUploadFileFile
 > = z.object({
   fileName: z.string(),
   content: z.union([
@@ -49,16 +52,22 @@ export const FileT$outboundSchema: z.ZodType<
   ]),
 });
 
-export function fileToJSON(fileT: FileT): string {
-  return JSON.stringify(FileT$outboundSchema.parse(fileT));
+export function bodyInsightsFolderUploadFileFileToJSON(
+  bodyInsightsFolderUploadFileFile: BodyInsightsFolderUploadFileFile,
+): string {
+  return JSON.stringify(
+    BodyInsightsFolderUploadFileFile$outboundSchema.parse(
+      bodyInsightsFolderUploadFileFile,
+    ),
+  );
 }
-export function fileFromJSON(
+export function bodyInsightsFolderUploadFileFileFromJSON(
   jsonString: string,
-): SafeParseResult<FileT, SDKValidationError> {
+): SafeParseResult<BodyInsightsFolderUploadFileFile, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => FileT$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FileT' from JSON`,
+    (x) => BodyInsightsFolderUploadFileFile$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BodyInsightsFolderUploadFileFile' from JSON`,
   );
 }
 
@@ -68,11 +77,11 @@ export const BodyInsightsFolderUploadFile$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  file: z.lazy(() => FileT$inboundSchema).optional(),
+  file: z.lazy(() => BodyInsightsFolderUploadFileFile$inboundSchema).optional(),
 });
 /** @internal */
 export type BodyInsightsFolderUploadFile$Outbound = {
-  file?: FileT$Outbound | Blob | undefined;
+  file?: BodyInsightsFolderUploadFileFile$Outbound | Blob | undefined;
 };
 
 /** @internal */
@@ -81,7 +90,9 @@ export const BodyInsightsFolderUploadFile$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   BodyInsightsFolderUploadFile
 > = z.object({
-  file: z.lazy(() => FileT$outboundSchema).or(blobLikeSchema).optional(),
+  file: z.lazy(() => BodyInsightsFolderUploadFileFile$outboundSchema).or(
+    blobLikeSchema,
+  ).optional(),
 });
 
 export function bodyInsightsFolderUploadFileToJSON(

package/src/models/components/callaction.ts

@@ -0,0 +1,331 @@
+/*
+ * 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";
+import {
+  CaseExpression,
+  CaseExpression$inboundSchema,
+  CaseExpression$Outbound,
+  CaseExpression$outboundSchema,
+} from "./caseexpression.js";
+import {
+  CelExpression,
+  CelExpression$inboundSchema,
+  CelExpression$Outbound,
+  CelExpression$outboundSchema,
+} from "./celexpression.js";
+import {
+  JMESPathExpression,
+  JMESPathExpression$inboundSchema,
+  JMESPathExpression$Outbound,
+  JMESPathExpression$outboundSchema,
+} from "./jmespathexpression.js";
+
+export type CallActionIf1 =
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" });
+
+/**
+ * An expression that must evaluate to true for the action to be applied.
+ */
+export type CallActionIf =
+  | CaseExpression
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" })
+  | string;
+
+/**
+ * Auto-population strategy: True (hybrid - synthetic or LLM), False (always LLM), "required" (synthetic only if all required args available, else LLM)
+ */
+export type AutoPopulate = boolean | string;
+
+export type CallAction = {
+  /**
+   * An expression that must evaluate to true for the action to be applied.
+   */
+  if?:
+    | CaseExpression
+    | (CelExpression & { type: "cel" })
+    | (JMESPathExpression & { type: "jmespath" })
+    | (JMESPathExpression & { type: "jp" })
+    | string
+    | null
+    | undefined;
+  action?: "call" | undefined;
+  /**
+   * The name of the tool to call.
+   */
+  name: string;
+  /**
+   * Optional arguments to pass to the tool (supports template strings)
+   */
+  arguments?: { [k: string]: any } | null | undefined;
+  /**
+   * Auto-population strategy: True (hybrid - synthetic or LLM), False (always LLM), "required" (synthetic only if all required args available, else LLM)
+   */
+  autoPopulate?: boolean | string | undefined;
+};
+
+/** @internal */
+export const CallActionIf1$inboundSchema: z.ZodType<
+  CallActionIf1,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  CelExpression$inboundSchema.and(
+    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
+  ),
+  JMESPathExpression$inboundSchema.and(
+    z.object({ type: z.literal("jmespath") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  JMESPathExpression$inboundSchema.and(
+    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+  ),
+]);
+/** @internal */
+export type CallActionIf1$Outbound =
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" });
+
+/** @internal */
+export const CallActionIf1$outboundSchema: z.ZodType<
+  CallActionIf1$Outbound,
+  z.ZodTypeDef,
+  CallActionIf1
+> = z.union([
+  CelExpression$outboundSchema.and(
+    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
+  ),
+  JMESPathExpression$outboundSchema.and(
+    z.object({ type: z.literal("jmespath") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
+  JMESPathExpression$outboundSchema.and(
+    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+  ),
+]);
+
+export function callActionIf1ToJSON(callActionIf1: CallActionIf1): string {
+  return JSON.stringify(CallActionIf1$outboundSchema.parse(callActionIf1));
+}
+export function callActionIf1FromJSON(
+  jsonString: string,
+): SafeParseResult<CallActionIf1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CallActionIf1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CallActionIf1' from JSON`,
+  );
+}
+
+/** @internal */
+export const CallActionIf$inboundSchema: z.ZodType<
+  CallActionIf,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  CaseExpression$inboundSchema,
+  z.union([
+    CelExpression$inboundSchema.and(
+      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
+    ),
+    JMESPathExpression$inboundSchema.and(
+      z.object({ type: z.literal("jmespath") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    JMESPathExpression$inboundSchema.and(
+      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    ),
+  ]),
+  z.string(),
+]);
+/** @internal */
+export type CallActionIf$Outbound =
+  | CaseExpression$Outbound
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" })
+  | string;
+
+/** @internal */
+export const CallActionIf$outboundSchema: z.ZodType<
+  CallActionIf$Outbound,
+  z.ZodTypeDef,
+  CallActionIf
+> = z.union([
+  CaseExpression$outboundSchema,
+  z.union([
+    CelExpression$outboundSchema.and(
+      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
+    ),
+    JMESPathExpression$outboundSchema.and(
+      z.object({ type: z.literal("jmespath") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
+    JMESPathExpression$outboundSchema.and(
+      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    ),
+  ]),
+  z.string(),
+]);
+
+export function callActionIfToJSON(callActionIf: CallActionIf): string {
+  return JSON.stringify(CallActionIf$outboundSchema.parse(callActionIf));
+}
+export function callActionIfFromJSON(
+  jsonString: string,
+): SafeParseResult<CallActionIf, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CallActionIf$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CallActionIf' from JSON`,
+  );
+}
+
+/** @internal */
+export const AutoPopulate$inboundSchema: z.ZodType<
+  AutoPopulate,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.boolean(), z.string()]);
+/** @internal */
+export type AutoPopulate$Outbound = boolean | string;
+
+/** @internal */
+export const AutoPopulate$outboundSchema: z.ZodType<
+  AutoPopulate$Outbound,
+  z.ZodTypeDef,
+  AutoPopulate
+> = z.union([z.boolean(), z.string()]);
+
+export function autoPopulateToJSON(autoPopulate: AutoPopulate): string {
+  return JSON.stringify(AutoPopulate$outboundSchema.parse(autoPopulate));
+}
+export function autoPopulateFromJSON(
+  jsonString: string,
+): SafeParseResult<AutoPopulate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AutoPopulate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AutoPopulate' from JSON`,
+  );
+}
+
+/** @internal */
+export const CallAction$inboundSchema: z.ZodType<
+  CallAction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  if: z.nullable(
+    z.union([
+      CaseExpression$inboundSchema,
+      z.union([
+        CelExpression$inboundSchema.and(
+          z.object({ type: z.literal("cel") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        JMESPathExpression$inboundSchema.and(
+          z.object({ type: z.literal("jmespath") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        JMESPathExpression$inboundSchema.and(
+          z.object({ type: z.literal("jp") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+      ]),
+      z.string(),
+    ]),
+  ).optional(),
+  action: z.literal("call").default("call"),
+  name: z.string(),
+  arguments: z.nullable(z.record(z.any())).optional(),
+  auto_populate: z.union([z.boolean(), z.string()]).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "auto_populate": "autoPopulate",
+  });
+});
+/** @internal */
+export type CallAction$Outbound = {
+  if?:
+    | CaseExpression$Outbound
+    | (CelExpression$Outbound & { type: "cel" })
+    | (JMESPathExpression$Outbound & { type: "jmespath" })
+    | (JMESPathExpression$Outbound & { type: "jp" })
+    | string
+    | null
+    | undefined;
+  action: "call";
+  name: string;
+  arguments?: { [k: string]: any } | null | undefined;
+  auto_populate?: boolean | string | undefined;
+};
+
+/** @internal */
+export const CallAction$outboundSchema: z.ZodType<
+  CallAction$Outbound,
+  z.ZodTypeDef,
+  CallAction
+> = z.object({
+  if: z.nullable(
+    z.union([
+      CaseExpression$outboundSchema,
+      z.union([
+        CelExpression$outboundSchema.and(
+          z.object({ type: z.literal("cel") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        JMESPathExpression$outboundSchema.and(
+          z.object({ type: z.literal("jmespath") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        JMESPathExpression$outboundSchema.and(
+          z.object({ type: z.literal("jp") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+      ]),
+      z.string(),
+    ]),
+  ).optional(),
+  action: z.literal("call").default("call" as const),
+  name: z.string(),
+  arguments: z.nullable(z.record(z.any())).optional(),
+  autoPopulate: z.union([z.boolean(), z.string()]).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    autoPopulate: "auto_populate",
+  });
+});
+
+export function callActionToJSON(callAction: CallAction): string {
+  return JSON.stringify(CallAction$outboundSchema.parse(callAction));
+}
+export function callActionFromJSON(
+  jsonString: string,
+): SafeParseResult<CallAction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CallAction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CallAction' from JSON`,
+  );
+}

package/src/models/components/caseexpression.ts

@@ -0,0 +1,53 @@
+/*
+ * 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 {
+  ConditionalValue,
+  ConditionalValue$inboundSchema,
+  ConditionalValue$Outbound,
+  ConditionalValue$outboundSchema,
+} from "./conditionalvalue.js";
+
+export type CaseExpression = {
+  case: Array<ConditionalValue>;
+};
+
+/** @internal */
+export const CaseExpression$inboundSchema: z.ZodType<
+  CaseExpression,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  case: z.array(z.lazy(() => ConditionalValue$inboundSchema)),
+});
+/** @internal */
+export type CaseExpression$Outbound = {
+  case: Array<ConditionalValue$Outbound>;
+};
+
+/** @internal */
+export const CaseExpression$outboundSchema: z.ZodType<
+  CaseExpression$Outbound,
+  z.ZodTypeDef,
+  CaseExpression
+> = z.object({
+  case: z.array(z.lazy(() => ConditionalValue$outboundSchema)),
+});
+
+export function caseExpressionToJSON(caseExpression: CaseExpression): string {
+  return JSON.stringify(CaseExpression$outboundSchema.parse(caseExpression));
+}
+export function caseExpressionFromJSON(
+  jsonString: string,
+): SafeParseResult<CaseExpression, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CaseExpression$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CaseExpression' from JSON`,
+  );
+}

package/src/models/components/celexpression.ts

@@ -0,0 +1,60 @@
+/*
+ * 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";
+
+/**
+ * See https://github.com/google/cel-spec/blob/master/doc/langdef.md
+ */
+export type CelExpression = {
+  /**
+   * The expression to evaluate.
+   */
+  expression: string;
+  /**
+   * Google Common Expression Language.
+   */
+  type?: "cel" | undefined;
+};
+
+/** @internal */
+export const CelExpression$inboundSchema: z.ZodType<
+  CelExpression,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  expression: z.string(),
+  type: z.literal("cel").default("cel"),
+});
+/** @internal */
+export type CelExpression$Outbound = {
+  expression: string;
+  type: "cel";
+};
+
+/** @internal */
+export const CelExpression$outboundSchema: z.ZodType<
+  CelExpression$Outbound,
+  z.ZodTypeDef,
+  CelExpression
+> = z.object({
+  expression: z.string(),
+  type: z.literal("cel").default("cel" as const),
+});
+
+export function celExpressionToJSON(celExpression: CelExpression): string {
+  return JSON.stringify(CelExpression$outboundSchema.parse(celExpression));
+}
+export function celExpressionFromJSON(
+  jsonString: string,
+): SafeParseResult<CelExpression, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CelExpression$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CelExpression' from JSON`,
+  );
+}