@sdk-it/typescript 0.33.3 → 0.34.1

package/dist/index.js

@@ -3,7 +3,7 @@ import { template as template2 } from "lodash-es";
 import { readdir } from "node:fs/promises";
 import { join as join2 } from "node:path";
 import { npmRunPathEnv } from "npm-run-path";
-import { camelcase as camelcase5, spinalcase as spinalcase4 } from "stringcase";
+import { camelcase as camelcase6, spinalcase as spinalcase4 } from "stringcase";
 import { methods, pascalcase as pascalcase5, toLitObject as toLitObject2 } from "@sdk-it/core";
 import {
   createWriterProxy,
@@ -19,34 +19,58 @@ import {
 } from "@sdk-it/spec";
 
 // packages/typescript/src/lib/agent/ai-sdk.ts
-import { camelcase, spinalcase } from "stringcase";
+import { camelcase } from "stringcase";
 import {
   forEachOperation
 } from "@sdk-it/spec";
-function generateAISDKTools(spec) {
+function generateAISDKTools(ir) {
   const groups = {};
-  forEachOperation(spec, (entry, operation) => {
-    groups[entry.tag] ??= [];
-    groups[entry.tag].push(createTool(entry, operation));
+  forEachOperation(ir, (entry, operation) => {
+    const tagDef = ir.tags.find((tag) => tag.name === entry.tag);
+    if (!tagDef) {
+      console.warn(`No tag details found for tag: ${entry.tag}`);
+      return;
+    }
+    groups[entry.tag] ??= {
+      tools: [],
+      instructions: "",
+      displayName: "",
+      name: ""
+    };
+    groups[entry.tag].tools.push(createTool(entry, operation));
+    groups[entry.tag].instructions = tagDef["x-instructions"];
+    groups[entry.tag].name = tagDef.name;
+    groups[entry.tag].displayName = tagDef["x-name"];
   });
   const imports = [
     `import { z } from 'zod';`,
     `import { tool } from 'ai';`,
     `import * as schemas from './inputs/index.ts';`
   ];
-  const tools = Object.entries(groups).map(([group, tools2]) => {
-    return `export const ${spinalcase(group)} = (context: { client: any }) => ({ ${tools2.join(", ")} });`;
-  });
-  return [...imports, ...tools].join("\n\n");
+  const agent = Object.entries(groups).map(
+    ([group, { instructions, tools, displayName }]) => {
+      return `export const ${camelcase(group)} = {
+    name: '${displayName}',
+    instructions: \`${instructions}\`,
+    tools: { ${tools.join(", ")} }
+    }`;
+    }
+  );
+  const handoffs = `export const triage = {
+  name: 'Triage Agent',
+  tools:{${Object.entries(groups).map(([, { name }]) => {
+    return createTransferTool(name);
+  })}}}`;
+  return [...imports, ...agent, handoffs].join("\n\n");
 }
 function createTool(entry, operation) {
   const schemaName = camelcase(`${operation.operationId} schema`);
   return `'${operation["x-fn-name"]}': tool({
       description: \`${operation.description || operation.summary}\`,
-			type: 'function',
       inputSchema: schemas.${schemaName},
-			execute: async (input) => {
+			execute: async (input, options) => {
 				console.log('Executing ${operation.operationId} tool with input:', input);
+        const context = coerceContext(options.experimental_context);
         const response = await context.client.request(
           '${entry.method.toUpperCase()} ${entry.path}' ,
           input as any,
@@ -55,6 +79,54 @@ function createTool(entry, operation) {
       },
     })`;
 }
+function createTransferTool(agentName) {
+  return `transfer_to_${agentName}: tool({
+      type: 'function',
+      description: 'Transfer the conversation to the ${agentName}.',
+      inputSchema: z.object({}),
+      execute: async () => ({ agent: '${agentName}' }),
+    })`;
+}
+
+// packages/typescript/src/lib/agent/openai-agents.ts
+import { camelcase as camelcase2, spinalcase } from "stringcase";
+import {
+  forEachOperation as forEachOperation2
+} from "@sdk-it/spec";
+function generateOpenAIAgentTools(spec) {
+  const groups = {};
+  forEachOperation2(spec, (entry, operation) => {
+    groups[entry.tag] ??= [];
+    groups[entry.tag].push(createTool2(entry, operation));
+  });
+  const imports = [
+    `import { z } from 'zod';`,
+    `import { tool } from '@openai/agents';`,
+    `import * as schemas from './inputs/index.ts';`
+  ];
+  const tools = Object.entries(groups).map(([group, tools2]) => {
+    return `export const ${spinalcase(group)} = [${tools2.join(", ")}];`;
+  });
+  return [...imports, ...tools].join("\n\n");
+}
+function createTool2(entry, operation) {
+  const schemaName = camelcase2(`${operation.operationId} schema`);
+  return `tool({
+      description: \`${operation.description || operation.summary}\`,
+      name: '${operation["x-fn-name"]}',
+      parameters: makeOptionalPropsNullable(schemas.${schemaName}),
+			execute: async (input, maybeContext) => {
+				console.log('Executing ${operation.operationId} tool with input:', input);
+        const context = coerceContext(maybeContext?.context);
+        const client = context.client;
+        const response = await client.request(
+          '${entry.method.toUpperCase()} ${entry.path}' ,
+          input as any,
+        );
+        return JSON.stringify(response);
+      },
+    })`;
+}
 
 // packages/typescript/src/lib/agent/utils.txt
 var utils_default = "function coerceContext(context?: any) {\n  if (!context) {\n    throw new Error('Context is required');\n  }\n  return context as {\n    client: any\n  };\n}\n/**\n * Takes a Zod object schema and makes all optional properties nullable as well.\n * This is useful for APIs where optional fields can be explicitly set to null.\n *\n * @param schema - The Zod object schema to transform\n * @returns A new Zod schema with optional properties made nullable\n */\nfunction makeOptionalPropsNullable<T extends z.ZodRawShape>(\n  schema: z.ZodObject<T>,\n) {\n  const shape = schema.shape;\n  const newShape = {} as Record<string, z.ZodTypeAny>;\n\n  for (const [key, value] of Object.entries(shape)) {\n    if (value instanceof z.ZodOptional) {\n      // Make optional properties also nullable\n      newShape[key] = value._def.innerType.nullable().optional();\n    } else {\n      // Keep non-optional properties as they are\n      newShape[key] = value;\n    }\n  }\n\n  return z.object(newShape);\n}";
@@ -350,6 +422,9 @@ var client_default = (spec, style) => {
     },
     baseUrl: {
       schema: spec.servers.length ? `z.enum(servers).default(servers[0])` : "z.string()"
+    },
+    headers: {
+      schema: "z.record(z.string()).optional()"
     }
   };
   return `import z from 'zod';
@@ -361,7 +436,7 @@ import {
   createHeadersInterceptor,
 } from './http/${spec.makeImport("interceptors")}';
 
-import { parseInput, type ParseError } from './http/${spec.makeImport("parser")}';
+import { type ParseError, parseInput } from './http/${spec.makeImport("parser")}';
 
 ${spec.servers.length ? `export const servers = ${JSON.stringify(spec.servers, null, 2)} as const` : ""}
 const optionsSchema = z.object(${toLitObject(specOptions, (x) => x.schema)});
@@ -436,7 +511,7 @@ export class ${spec.name} {
   }
 
   get defaultHeaders() {
-    return ${defaultHeaders}
+    return { ...${defaultHeaders}, ...this.options.headers}
   }
 
   get #defaultInputs() {
@@ -625,14 +700,14 @@ function appendOptional2(type, isRequired) {
 // packages/typescript/src/lib/generator.ts
 import { merge, template } from "lodash-es";
 import { join } from "node:path";
-import { camelcase as camelcase3, spinalcase as spinalcase2 } from "stringcase";
+import { camelcase as camelcase4, spinalcase as spinalcase2 } from "stringcase";
 import { followRef as followRef3, isEmpty as isEmpty2, isRef as isRef3, resolveRef } from "@sdk-it/core";
 import {
-  forEachOperation as forEachOperation2
+  forEachOperation as forEachOperation3
 } from "@sdk-it/spec";
 
 // packages/typescript/src/lib/sdk.ts
-import { camelcase as camelcase2 } from "stringcase";
+import { camelcase as camelcase3 } from "stringcase";
 import { isEmpty, pascalcase as pascalcase3 } from "@sdk-it/core";
 import {
   isStreamingContentType,
@@ -672,8 +747,8 @@ var status_map_default = {
 
 // packages/typescript/src/lib/sdk.ts
 function toEndpoint(groupName, spec, specOperation, operation, utils) {
-  const schemaName = camelcase2(`${specOperation.operationId} schema`);
-  const schemaRef = `${camelcase2(groupName)}.${schemaName}`;
+  const schemaName = camelcase3(`${specOperation.operationId} schema`);
+  const schemaRef = `${camelcase3(groupName)}.${schemaName}`;
   const schemas = [];
   specOperation.responses ??= {};
   const outputs = Object.keys(specOperation.responses).flatMap(
@@ -939,7 +1014,7 @@ function generateCode(config) {
   });
   const groups = {};
   const endpoints = {};
-  forEachOperation2(config.spec, (entry, operation) => {
+  forEachOperation3(config.spec, (entry, operation) => {
     console.log(`Processing ${entry.method} ${entry.path}`);
     groups[entry.tag] ??= [];
     endpoints[entry.tag] ??= [];
@@ -987,8 +1062,8 @@ function generateCode(config) {
     });
   });
   const allSchemas = Object.keys(endpoints).map((it) => ({
-    import: `import ${camelcase3(it)} from './${config.makeImport(spinalcase2(it))}';`,
-    use: `  ...${camelcase3(it)}`
+    import: `import ${camelcase4(it)} from './${config.makeImport(spinalcase2(it))}';`,
+    use: `  ...${camelcase4(it)}`
   }));
   return {
     groups,
@@ -1024,7 +1099,7 @@ ${allSchemas.map((it) => it.use).join(",\n")}
                 `import * as outputs from '${config.makeImport("../outputs/index")}';`,
                 `import { toRequest, json, urlencoded, empty, formdata, type HeadersInit } from '${config.makeImport("../http/request")}';`,
                 `import { chunked, buffered } from "${config.makeImport("../http/parse-response")}";`,
-                `import * as ${camelcase3(name)} from '../inputs/${config.makeImport(spinalcase2(name))}';`,
+                `import * as ${camelcase4(name)} from '../inputs/${config.makeImport(spinalcase2(name))}';`,
                 `import { createBaseUrlInterceptor, createHeadersInterceptor, type Interceptor } from '${config.makeImport("../http/interceptors")}';`,
                 `import { Dispatcher, fetchType, type InstanceType } from '${config.makeImport("../http/dispatcher")}';`,
                 `import { Pagination, OffsetPagination, CursorPagination } from "${config.makeImport("../pagination/index")}";`
@@ -1609,7 +1684,7 @@ var page_pagination_default = "type InferPage<T> = T extends Page<infer U> ? U :
 
 // packages/typescript/src/lib/readme/readme.ts
 import { isEmpty as isEmpty3 } from "@sdk-it/core";
-import { forEachOperation as forEachOperation3 } from "@sdk-it/spec";
+import { forEachOperation as forEachOperation4 } from "@sdk-it/spec";
 
 // packages/typescript/src/lib/readme/prop.emitter.ts
 import { followRef as followRef4, isRef as isRef4 } from "@sdk-it/core";
@@ -1920,7 +1995,7 @@ function toReadme(spec, generator) {
   markdown.push("");
   markdown.push("## API Reference");
   markdown.push("");
-  forEachOperation3(spec, (entry, operation) => {
+  forEachOperation4(spec, (entry, operation) => {
     const { method, path } = entry;
     markdown.push(
       `### ${operation["x-fn-name"]} | ${`_${method.toUpperCase()} ${path}_`}`
@@ -1993,11 +2068,11 @@ ${l}`));
 }
 
 // packages/typescript/src/lib/typescript-snippet.ts
-import { camelcase as camelcase4, spinalcase as spinalcase3 } from "stringcase";
+import { camelcase as camelcase5, spinalcase as spinalcase3 } from "stringcase";
 import { isEmpty as isEmpty4, pascalcase as pascalcase4, resolveRef as resolveRef3 } from "@sdk-it/core";
 import "@sdk-it/readme";
 import {
-  forEachOperation as forEachOperation4,
+  forEachOperation as forEachOperation5,
   patchParameters,
   securityToOptions
 } from "@sdk-it/spec";
@@ -2018,7 +2093,7 @@ var SnippetEmitter = class {
     for (const [propName, propSchema] of Object.entries(properties)) {
       const isRequired = (schemaObj.required ?? []).includes(propName);
       const resolvedProp = resolveRef2(this.spec, propSchema);
-      if (isRequired || resolvedProp.example !== void 0 || resolvedProp.default !== void 0 || Math.random() > 0.5) {
+      if (isRequired || resolvedProp.example !== void 0 || resolvedProp.default !== void 0) {
         result[propName] = this.handle(propSchema);
       }
     }
@@ -2320,7 +2395,7 @@ var TypeScriptSnippet = class {
     };
   }
   #toRequest(entry, payload) {
-    return `await ${camelcase4(this.#clientName)}.request('${entry.method.toUpperCase()} ${entry.path}', ${payload});`;
+    return `await ${camelcase5(this.#clientName)}.request('${entry.method.toUpperCase()} ${entry.path}', ${payload});`;
   }
   snippet(entry, operation, config = {}) {
     const payload = this.succinct(entry, operation, config);
@@ -2361,7 +2436,7 @@ ${client.use}`;
   #constructClient(options = {}) {
     return {
       import: `import { ${this.#clientName} } from '${this.#packageName}';`,
-      use: `const ${camelcase4(this.#clientName)} = new ${this.#clientName}({
+      use: `const ${camelcase5(this.#clientName)} = new ${this.#clientName}({
 		${Object.entries(
         options
       ).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(",\n		")}
@@ -2896,7 +2971,7 @@ function availablePaginationTypes(spec) {
   let offset = false;
   let page = false;
   let cursor = false;
-  forEachOperation4(spec, (entry, operation) => {
+  forEachOperation5(spec, (entry, operation) => {
     if (operation["x-pagination"]) {
       switch (operation["x-pagination"].type) {
         case "offset":
@@ -3087,12 +3162,19 @@ ${template2(dispatcher_default, {})({ throwError: !style.errorAsValue, outputTyp
     "models/index.ts": modelsIndex
     // ...(modelsImports.length ? { 'models/index.ts': modelsIndex } : {}),
   });
-  if (settings.agentTools) {
-    await settings.writer(output, {
-      "agents.ts": `${generateAISDKTools(spec)}
+  switch (settings.agentTools) {
+    case "openai-agents":
+      await settings.writer(output, {
+        "agents.ts": `${generateOpenAIAgentTools(spec)}
 ${utils_default}`
-      // 'agents.ts': `${generateOpenAIAgentTools(spec)}\n${utilsTxt}`,
-    });
+      });
+      break;
+    case "ai-sdk":
+      await settings.writer(output, {
+        "agents.ts": `${generateAISDKTools(spec)}
+${utils_default}`
+      });
+      break;
   }
   await settings.writer(output, {
     "index.ts": await getFolderExports(
@@ -3217,7 +3299,7 @@ function toInputs(operationsSet, commonZod, makeImport) {
     const output = [];
     const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
     for (const operation of operations) {
-      const schemaName = camelcase5(`${operation.operationId} schema`);
+      const schemaName = camelcase6(`${operation.operationId} schema`);
       const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject2(operation.schemas)};`;
       for (const it of commonImports) {
         if (schema.includes(it)) {