@sdk-it/typescript 0.34.0 → 0.35.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from './lib/generate.js';
-export * from './lib/typescript-snippet.js';
 export * from './lib/generator.js';
 export * from './lib/sdk.js';
+export * from './lib/typescript-snippet.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,6BAA6B,CAAC"}

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,35 +19,107 @@ 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,
+        );
+        return JSON.stringify(response);
+      },
+    })`;
+}
+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,
         );
@@ -628,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,
@@ -675,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(
@@ -942,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] ??= [];
@@ -990,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,
@@ -1027,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")}";`
@@ -1612,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";
@@ -1923,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}_`}`
@@ -1996,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";
@@ -2021,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);
       }
     }
@@ -2323,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);
@@ -2364,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		")}
@@ -2899,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":
@@ -3090,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(
@@ -3220,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)) {