@sdk-it/typescript 0.28.0 → 0.29.0

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 camelcase4, spinalcase as spinalcase3 } from "stringcase";
+import { camelcase as camelcase5, spinalcase as spinalcase4 } from "stringcase";
 import { methods, pascalcase as pascalcase5, toLitObject as toLitObject2 } from "@sdk-it/core";
 import {
   createWriterProxy,
@@ -13,12 +13,50 @@ import {
 import {
   augmentSpec,
   cleanFiles,
-  forEachOperation as forEachOperation4,
   readWriteMetadata,
   sanitizeTag as sanitizeTag4,
   securityToOptions as securityToOptions2
 } from "@sdk-it/spec";
 
+// packages/typescript/src/lib/agent/ai-sdk.ts
+import { camelcase, spinalcase } from "stringcase";
+import {
+  forEachOperation
+} from "@sdk-it/spec";
+function generateAISDKTools(spec) {
+  const groups = {};
+  forEachOperation(spec, (entry, operation) => {
+    groups[entry.tag] ??= [];
+    groups[entry.tag].push(createTool(entry, operation));
+  });
+  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");
+}
+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) => {
+				console.log('Executing ${operation.operationId} tool with input:', input);
+        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}";
 
@@ -588,58 +626,25 @@ function appendOptional2(type, isRequired) {
 // packages/typescript/src/lib/generator.ts
 import { merge, template } from "lodash-es";
 import { join } from "node:path";
-import { camelcase as camelcase2, spinalcase } from "stringcase";
+import { camelcase as camelcase3, spinalcase as spinalcase2 } from "stringcase";
 import { followRef as followRef3, isEmpty as isEmpty2, isRef as isRef3, resolveRef } from "@sdk-it/core";
-import { forEachOperation } from "@sdk-it/spec";
-
-// packages/typescript/src/lib/import-utilities.ts
-import { removeDuplicates } from "@sdk-it/core";
-function mergeImports(...imports) {
-  const merged = {};
-  for (const it of imports) {
-    merged[it.moduleSpecifier] = merged[it.moduleSpecifier] ?? {
-      moduleSpecifier: it.moduleSpecifier,
-      defaultImport: it.defaultImport,
-      namespaceImport: it.namespaceImport,
-      namedImports: []
-    };
-    for (const named of it.namedImports) {
-      if (!merged[it.moduleSpecifier].namedImports.some(
-        (x) => x.name === named.name
-      )) {
-        merged[it.moduleSpecifier].namedImports.push(named);
-      }
-    }
-  }
-  return Object.values(merged);
-}
-function importsToString(...imports) {
-  return imports.map((it) => {
-    if (it.defaultImport) {
-      return `import ${it.defaultImport} from '${it.moduleSpecifier}'`;
-    }
-    if (it.namespaceImport) {
-      return `import * as ${it.namespaceImport} from '${it.moduleSpecifier}'`;
-    }
-    if (it.namedImports) {
-      return `import {${removeDuplicates(it.namedImports, (it2) => it2.name).map((n) => `${n.isTypeOnly ? "type" : ""} ${n.name}`).join(", ")}} from '${it.moduleSpecifier}'`;
-    }
-    throw new Error(`Invalid import ${JSON.stringify(it)}`);
-  });
-}
+import {
+  forEachOperation as forEachOperation2
+} from "@sdk-it/spec";
 
 // packages/typescript/src/lib/sdk.ts
-import { camelcase } from "stringcase";
+import { camelcase as camelcase2 } from "stringcase";
 import { isEmpty, pascalcase as pascalcase3 } from "@sdk-it/core";
 import {
-  isErrorStatusCode,
   isStreamingContentType,
-  isSuccessStatusCode,
   isTextContentType,
   parseJsonContentType,
   sanitizeTag as sanitizeTag3
 } from "@sdk-it/spec";
 
+// packages/typescript/src/lib/import-utilities.ts
+import { removeDuplicates } from "@sdk-it/core";
+
 // packages/typescript/src/lib/status-map.ts
 var status_map_default = {
   "200": "Ok",
@@ -668,52 +673,25 @@ var status_map_default = {
 
 // packages/typescript/src/lib/sdk.ts
 function toEndpoint(groupName, spec, specOperation, operation, utils) {
-  const schemaName = camelcase(`${operation.name} schema`);
-  const schemaRef = `${camelcase(groupName)}.${schemaName}`;
-  const inputHeaders = [];
-  const inputQuery = [];
-  const inputBody = [];
-  const inputParams = [];
+  const schemaName = camelcase2(`${specOperation.operationId} schema`);
+  const schemaRef = `${camelcase2(groupName)}.${schemaName}`;
   const schemas = [];
-  const responses = [];
-  for (const [name, prop] of Object.entries(operation.inputs)) {
-    if (prop.in === "headers" || prop.in === "header") {
-      inputHeaders.push(`"${name}"`);
-    } else if (prop.in === "query") {
-      inputQuery.push(`"${name}"`);
-    } else if (prop.in === "body") {
-      inputBody.push(`"${name}"`);
-    } else if (prop.in === "path") {
-      inputParams.push(`"${name}"`);
-    } else if (prop.in === "internal") {
-      continue;
-    } else {
-      throw new Error(
-        `Unknown source ${prop.in} in ${name} ${JSON.stringify(
-          prop
-        )} in ${operation.name}`
-      );
-    }
-  }
   specOperation.responses ??= {};
-  const outputs = [];
-  for (const status in specOperation.responses) {
-    const handled = handleResponse(
+  const outputs = Object.keys(specOperation.responses).flatMap(
+    (status) => toHttpOutput(
       spec,
-      operation.name,
+      specOperation.operationId,
       status,
-      specOperation.responses[status],
-      utils
-    );
-    responses.push(handled);
-    outputs.push(...handled.outputs);
-  }
+      specOperation.responses[status]
+    )
+  );
   const addTypeParser = Object.keys(operation.schemas).length > 1;
   for (const type in operation.schemas ?? {}) {
     let typePrefix = "";
     if (addTypeParser && type !== "json") {
       typePrefix = `${type} `;
     }
+    const paths = inputToPath(specOperation, operation.inputs);
     const endpoint = `${typePrefix}${operation.method.toUpperCase()} ${operation.path}`;
     schemas.push(
       `"${endpoint}": {
@@ -721,10 +699,10 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
           output:[${outputs.join(",")}],
           toRequest(input: z.infer<typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}>) {
            return toRequest('${endpoint}', ${operation.outgoingContentType || "empty"}(input, {
-              inputHeaders: [${inputHeaders}],
-              inputQuery: [${inputQuery}],
-              inputBody: [${inputBody}],
-              inputParams: [${inputParams}],
+              inputHeaders: [${paths.inputHeaders}],
+              inputQuery: [${paths.inputQuery}],
+              inputBody: [${paths.inputBody}],
+              inputParams: [${paths.inputParams}],
             }));},
          async dispatch(input: z.infer<typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}>,options: {
             signal?: AbortSignal;
@@ -733,7 +711,7 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
           })${specOperation["x-pagination"] ? paginationOperation(specOperation, utils.style) : normalOperation(utils.style)}`
     );
   }
-  return { responses, schemas };
+  return { schemas };
 }
 function normalOperation(style) {
   return `{
@@ -819,32 +797,10 @@ function paginationOperation(operation, style) {
   }
   return normalOperation(style);
 }
-function handleResponse(spec, operationName, status, response, utils) {
-  const schemas = {};
-  const imports = {};
-  const endpointImports = {
-    ParseError: {
-      defaultImport: void 0,
-      isTypeOnly: false,
-      moduleSpecifier: utils.makeImport(`../http/parser`),
-      namedImports: [{ isTypeOnly: false, name: "ParseError" }],
-      namespaceImport: void 0
-    }
-  };
-  const responses = [];
-  const outputs = [];
+function toHttpOutput(spec, operationName, status, response, withGenerics = true) {
   const typeScriptDeserialzer = new TypeScriptEmitter(spec);
-  const statusCode = +status;
-  const statusName = `http.${status_map_default[status] || "APIResponse"}`;
   const interfaceName = pascalcase3(sanitizeTag3(response["x-response-name"]));
-  let parser = "buffered";
-  if (isEmpty(response.content)) {
-    responses.push({
-      name: interfaceName,
-      schema: "void",
-      description: response.description
-    });
-  } else {
+  if (!isEmpty(response.content)) {
     const contentTypeResult = fromContentType(
       spec,
       typeScriptDeserialzer,
@@ -855,33 +811,27 @@ function handleResponse(spec, operationName, status, response, utils) {
         `No recognizable content type for response ${status} in operation ${operationName}`
       );
     }
-    parser = contentTypeResult.parser;
-    const responseSchema = contentTypeResult.responseSchema;
-    responses.push({
-      name: interfaceName,
-      schema: responseSchema,
-      description: response.description
-    });
-    if (isErrorStatusCode(statusCode)) {
-      endpointImports[status_map_default[status] ?? "APIError"] = {
-        moduleSpecifier: utils.makeImport("../http/response"),
-        namedImports: [{ name: status_map_default[status] ?? "APIError" }]
-      };
-    } else if (isSuccessStatusCode(statusCode)) {
-    }
-  }
-  if (statusCode === 204) {
-    outputs.push(statusName);
-  } else {
-    if (status.endsWith("XX")) {
-      outputs.push(`http.APIError<outputs.${interfaceName}>`);
+    const parser = contentTypeResult.parser || "buffered";
+    const outputs = [];
+    const statusName = `http.${status_map_default[status] || "APIResponse"}`;
+    const statusCode = +status;
+    if (statusCode === 204) {
+      outputs.push(statusName);
     } else {
-      outputs.push(
-        parser !== "buffered" ? `{type: ${statusName}<outputs.${interfaceName}>, parser: ${parser}}` : `${statusName}<outputs.${interfaceName}>`
-      );
+      const generic = withGenerics ? `<outputs.${interfaceName}>` : "";
+      if (status.endsWith("XX")) {
+        outputs.push(`http.APIError${generic}`);
+      } else {
+        if (parser !== "buffered") {
+          outputs.push(`{type: ${statusName}${generic}, parser: ${parser}}`);
+        } else {
+          outputs.push(`${statusName}${generic}`);
+        }
+      }
     }
+    return outputs;
   }
-  return { schemas, imports, endpointImports, responses, outputs };
+  return [];
 }
 function fromContentType(spec, typeScriptDeserialzer, response) {
   if ((response.headers ?? {})["Transfer-Encoding"]) {
@@ -912,11 +862,71 @@ function streamedOutput() {
     responseSchema: "ReadableStream"
   };
 }
+function inputToPath(operation, inputs) {
+  const inputHeaders = [];
+  const inputQuery = [];
+  const inputBody = [];
+  const inputParams = [];
+  for (const [name, prop] of Object.entries(inputs)) {
+    if (prop.in === "headers" || prop.in === "header") {
+      inputHeaders.push(`"${name}"`);
+    } else if (prop.in === "query") {
+      inputQuery.push(`"${name}"`);
+    } else if (prop.in === "body") {
+      inputBody.push(`"${name}"`);
+    } else if (prop.in === "path") {
+      inputParams.push(`"${name}"`);
+    } else if (prop.in === "internal") {
+      continue;
+    } else {
+      throw new Error(
+        `Unknown source ${prop.in} in ${name} ${JSON.stringify(
+          prop
+        )} in ${operation.operationId}`
+      );
+    }
+  }
+  return {
+    inputHeaders,
+    inputQuery,
+    inputBody,
+    inputParams
+  };
+}
 
 // packages/typescript/src/lib/styles/github/endpoints.txt
 var endpoints_default = "type EndpointOutput<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  SuccessfulResponse\n>;\n\ntype EndpointError<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  ProblematicResponse\n>;\n\nexport type Endpoints = {\n  [K in keyof typeof schemas]: {\n    input: z.infer<(typeof schemas)[K]['schema']>;\n    output: <% if (outputType === 'default') { %>EndpointOutput<K>['data']<% } else { %>EndpointOutput<K><% } %>;\n    error: EndpointError<K> | ParseError<(typeof schemas)[K]['schema']>;\n  };\n};";
 
 // packages/typescript/src/lib/generator.ts
+function coearceRequestInput(spec, operation, type) {
+  let objectSchema = resolveRef(
+    spec,
+    operation.requestBody.content[type].schema
+  );
+  const xProperties = objectSchema["x-properties"] ?? {};
+  const xRequired = objectSchema["x-required"] ?? [];
+  if (type === "application/empty") {
+    objectSchema = {
+      type: "object",
+      additionalProperties: isEmpty2(xProperties)
+    };
+  } else {
+    if (objectSchema.type !== "object") {
+      objectSchema = {
+        type: "object",
+        required: [operation.requestBody.required ? "$body" : ""],
+        properties: {
+          $body: objectSchema
+        }
+      };
+    }
+  }
+  return {
+    objectSchema,
+    xProperties,
+    xRequired
+  };
+}
 function generateCode(config) {
   const commonZod = /* @__PURE__ */ new Map();
   const commonZodImports = [];
@@ -932,11 +942,10 @@ function generateCode(config) {
   });
   const groups = {};
   const endpoints = {};
-  forEachOperation(config.spec, (entry, operation) => {
+  forEachOperation2(config.spec, (entry, operation) => {
     console.log(`Processing ${entry.method} ${entry.path}`);
     groups[entry.tag] ??= [];
     endpoints[entry.tag] ??= [];
-    const inputs = {};
     const schemas = {};
     const shortContenTypeMap = {
       "application/json": "json",
@@ -949,30 +958,12 @@ function generateCode(config) {
       "application/xml": "xml",
       "text/plain": "text"
     };
-    let outgoingContentType = "empty";
     for (const type in operation.requestBody.content) {
-      let objectSchema = resolveRef(
+      const { objectSchema, xProperties, xRequired } = coearceRequestInput(
         config.spec,
-        operation.requestBody.content[type].schema
+        operation,
+        type
       );
-      const xProperties = objectSchema["x-properties"] ?? {};
-      const xRequired = objectSchema["x-required"] ?? [];
-      if (type === "application/empty") {
-        objectSchema = {
-          type: "object",
-          additionalProperties: isEmpty2(xProperties)
-        };
-      } else {
-        if (objectSchema.type !== "object") {
-          objectSchema = {
-            type: "object",
-            required: [operation.requestBody.required ? "$body" : ""],
-            properties: {
-              $body: objectSchema
-            }
-          };
-        }
-      }
       const additionalProperties = {};
       for (const [name, prop] of Object.entries(xProperties)) {
         additionalProperties[name] = {
@@ -981,10 +972,6 @@ function generateCode(config) {
           schema: prop,
           in: prop["x-in"]
         };
-        inputs[name] = {
-          in: prop["x-in"],
-          schema: ""
-        };
       }
       const schema = merge({}, objectSchema, {
         required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
@@ -993,43 +980,36 @@ function generateCode(config) {
           {}
         )
       });
-      Object.assign(inputs, bodyInputs(config.spec, objectSchema));
       schemas[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
     }
-    if (operation.requestBody.content["application/json"]) {
-      outgoingContentType = "json";
-    } else if (operation.requestBody.content["application/x-www-form-urlencoded"]) {
-      outgoingContentType = "urlencoded";
-    } else if (operation.requestBody.content["multipart/form-data"]) {
-      outgoingContentType = "formdata";
-    }
+    const details = buildInput(config.spec, operation);
     const endpoint = toEndpoint(
       entry.tag,
       config.spec,
       operation,
       {
-        outgoingContentType,
-        name: operation.operationId,
         method: entry.method,
         path: entry.path,
+        operationId: operation.operationId,
         schemas,
-        inputs
+        outgoingContentType: details.outgoingContentType,
+        inputs: details.inputs
       },
-      { makeImport: config.makeImport, style: config.style }
+      config
     );
     endpoints[entry.tag].push(endpoint);
     groups[entry.tag].push({
-      name: operation.operationId,
-      inputs,
-      outgoingContentType,
-      schemas,
       method: entry.method,
-      path: entry.path
+      path: entry.path,
+      operationId: operation.operationId,
+      schemas,
+      outgoingContentType: details.outgoingContentType,
+      inputs: details.inputs
     });
   });
   const allSchemas = Object.keys(endpoints).map((it) => ({
-    import: `import ${camelcase2(it)} from './${config.makeImport(spinalcase(it))}';`,
-    use: `  ...${camelcase2(it)}`
+    import: `import ${camelcase3(it)} from './${config.makeImport(spinalcase2(it))}';`,
+    use: `  ...${camelcase3(it)}`
   }));
   return {
     groups,
@@ -1056,26 +1036,16 @@ ${allSchemas.map((it) => it.use).join(",\n")}
 `.trim(),
       ...Object.fromEntries(
         Object.entries(endpoints).map(([name, endpoint]) => {
-          const imps = importsToString(
-            ...mergeImports(
-              ...endpoint.flatMap(
-                (it) => it.responses.flatMap(
-                  (it2) => Object.values(it2.endpointImports)
-                )
-              )
-            )
-          );
           return [
             [
-              join("api", `${spinalcase(name)}.ts`),
+              join("api", `${spinalcase2(name)}.ts`),
               `${[
-                ...imps,
                 `import z from 'zod';`,
                 `import * as http from '${config.makeImport("../http/response")}';`,
                 `import * as outputs from '${config.makeImport("../outputs/index")}';`,
                 `import { toRequest, json, urlencoded, empty, formdata, createUrl, type HeadersInit } from '${config.makeImport("../http/request")}';`,
                 `import { chunked, buffered } from "${config.makeImport("../http/parse-response")}";`,
-                `import * as ${camelcase2(name)} from '../inputs/${config.makeImport(spinalcase(name))}';`,
+                `import * as ${camelcase3(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")}";`
@@ -1137,6 +1107,40 @@ function bodyInputs(spec, ctSchema) {
     {}
   );
 }
+var contentTypeMap = {
+  "application/json": "json",
+  "application/x-www-form-urlencoded": "urlencoded",
+  "multipart/form-data": "formdata",
+  "application/xml": "xml",
+  "text/plain": "text",
+  "application/empty": "empty"
+};
+function buildInput(spec, operation) {
+  const inputs = {};
+  let outgoingContentType = "empty";
+  for (const [ct, value] of Object.entries(contentTypeMap)) {
+    if (operation.requestBody.content[ct]) {
+      outgoingContentType = value;
+      const { objectSchema, xProperties } = coearceRequestInput(
+        spec,
+        operation,
+        ct
+      );
+      for (const [name, prop] of Object.entries(xProperties)) {
+        inputs[name] = {
+          in: prop["x-in"],
+          schema: ""
+        };
+      }
+      Object.assign(inputs, bodyInputs(spec, objectSchema));
+      break;
+    }
+  }
+  return {
+    inputs,
+    outgoingContentType
+  };
+}
 
 // packages/typescript/src/lib/http/dispatcher.txt
 var dispatcher_default = "export type Unionize<T> = T extends [infer Single extends OutputType]\n  ? InstanceType<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: InstanceType<Tuple[I]> }[number]\n    : never;\n\nexport type InstanceType<T> =\n  T extends Type<infer U>\n    ? U\n    : T extends { type: Type<infer U> }\n      ? U\n      : T extends Array<unknown>\n        ? Unionize<T>\n        : never;\n\nexport interface Type<T> {\n  new (...args: any[]): T;\n}\nexport type Parser = (\n  response: Response,\n) => Promise<unknown> | ReadableStream<any>;\nexport type OutputType =\n  | Type<APIResponse>\n  | { parser: Parser; type: Type<APIResponse> };\n\nexport const fetchType = z\n  .function()\n  .args(z.instanceof(Request))\n  .returns(z.promise(z.instanceof(Response)))\n  .optional();\n\nexport async function parse<T extends OutputType[]>(\n  outputs: T,\n  response: Response,\n) <% if(!throwError) { %>\n: Promise<\n  [\n    Extract<InstanceType<T>, SuccessfulResponse>['data'],\n    Extract<InstanceType<T>, ProblematicResponse>['data'],\n  ]\n>\n  <% } %>\n\n\n\n {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of outputs) {\n    if ('parser' in outputType) {\n      parser = outputType.parser;\n      if (isTypeOf(outputType.type, APIResponse)) {\n        if (response.status === outputType.type.status) {\n          output = outputType.type;\n          break;\n        }\n      }\n    } else if (isTypeOf(outputType, APIResponse)) {\n      if (response.status === outputType.status) {\n        output = outputType;\n        break;\n      }\n    }\n  }\n\n\n  if (response.ok) {\n    const apiresponse = (output || APIResponse).create(\n      response.status,\n      await parser(response),\n    );\n    <% if(throwError) { %>\n      return <% if (outputType === 'default') { %>apiresponse as Extract<InstanceType<T>, SuccessfulResponse><% } else { %>apiresponse as Extract<InstanceType<T>, SuccessfulResponse>;<% } %>;\n    <% } else { %>\n      return [<% if (outputType === 'default') { %>apiresponse.data as Extract<InstanceType<T>, SuccessfulResponse>['data']<% } else { %>apiresponse as Extract<InstanceType<T>, SuccessfulResponse><% } %>, null] as const;\n    <% } %>\n  }\n<% if(throwError) { %>\n  throw (output || APIError).create(\n    response.status,\n    await parser(response),\n  );\n<% } else { %>\n  const data = (output || APIError).create(\n    response.status,\n    await parser(response),\n  );\n  return [null, data] as const;\n<% } %>\n}\n\nexport function isTypeOf<T extends Type<APIResponse>>(\n  instance: any,\n  baseType: T,\n): instance is T {\n  if (instance === baseType) {\n    return true;\n  }\n  const prototype = Object.getPrototypeOf(instance);\n  if (prototype === null) {\n    return false;\n  }\n  return isTypeOf(prototype, baseType);\n}\n\nexport class Dispatcher {\n  #interceptors: Interceptor[] = [];\n  #fetch: z.infer<typeof fetchType>;\n  constructor(interceptors: Interceptor[], fetch?: z.infer<typeof fetchType>) {\n    this.#interceptors = interceptors;\n    this.#fetch = fetch;\n  }\n\n  async send<T extends OutputType[]>(\n    config: RequestConfig,\n    outputs: T,\n    signal?: AbortSignal,\n  ) {\n    for (const interceptor of this.#interceptors) {\n      if (interceptor.before) {\n        config = await interceptor.before(config);\n      }\n    }\n\n    let response = await (this.#fetch ?? fetch)(\n      new Request(config.url, config.init),\n      {\n        ...config.init,\n        signal: signal,\n      },\n    );\n\n    for (let i = this.#interceptors.length - 1; i >= 0; i--) {\n      const interceptor = this.#interceptors[i];\n      if (interceptor.after) {\n        response = await interceptor.after(response.clone());\n      }\n    }\n\n    return await parse(outputs, response);\n  }\n}\n";
@@ -1599,7 +1603,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 forEachOperation2 } from "@sdk-it/spec";
+import { forEachOperation as forEachOperation3 } from "@sdk-it/spec";
 
 // packages/typescript/src/lib/readme/prop.emitter.ts
 import { followRef as followRef4, isRef as isRef4 } from "@sdk-it/core";
@@ -1889,7 +1893,7 @@ function toReadme(spec, generator) {
   markdown.push(`# ${spec.info.title} TypeScript SDK`);
   markdown.push("");
   markdown.push(
-    "A fully-typed TypeScript SDK with comprehensive IntelliSense support, automatic request/response validation, and modern async/await patterns. Built for seamless integration with TypeScript and JavaScript projects."
+    "A fully-typed TypeScript SDK with comprehensive IntelliSense support, automatic request/response validation, and modern async/await patterns. Built for seamless integration with TypeScript and JavaScript projects. Each endpoint includes a brief description, example usage, and details about request and response formats."
   );
   markdown.push("");
   markdown.push(generator.clientSetupDocs());
@@ -1910,7 +1914,7 @@ function toReadme(spec, generator) {
   markdown.push("");
   markdown.push("## API Reference");
   markdown.push("");
-  forEachOperation2(spec, (entry, operation) => {
+  forEachOperation3(spec, (entry, operation) => {
     const { method, path } = entry;
     markdown.push(
       `### ${operation["x-fn-name"]} | ${`_${method.toUpperCase()} ${path}_`}`
@@ -1983,11 +1987,11 @@ ${l}`));
 }
 
 // packages/typescript/src/lib/typescript-snippet.ts
-import { camelcase as camelcase3, spinalcase as spinalcase2 } from "stringcase";
+import { camelcase as camelcase4, 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 forEachOperation3,
+  forEachOperation as forEachOperation4,
   patchParameters,
   securityToOptions
 } from "@sdk-it/spec";
@@ -2038,11 +2042,11 @@ var SnippetEmitter = class {
     switch (schema.format) {
       case "date-time":
       case "datetime":
-        return (/* @__PURE__ */ new Date()).toISOString();
+        return `2025-07-17T09:08:00.097Z`;
       case "date":
-        return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        return `2025-07-17`;
       case "time":
-        return (/* @__PURE__ */ new Date()).toISOString().split("T")[1];
+        return `09:08:00.097Z`;
       case "email":
         return "user@example.com";
       case "uuid":
@@ -2182,7 +2186,7 @@ var SnippetEmitter = class {
 };
 
 // packages/typescript/src/lib/typescript-snippet.ts
-var TypeScriptGenerator = class {
+var TypeScriptSnippet = class {
   #spec;
   #settings;
   #snippetEmitter;
@@ -2193,7 +2197,7 @@ var TypeScriptGenerator = class {
     this.#settings = settings;
     this.#snippetEmitter = new SnippetEmitter(spec);
     this.#clientName = settings.name?.trim() ? pascalcase4(settings.name) : "Client";
-    this.#packageName = settings.name ? `@${spinalcase2(this.#clientName.toLowerCase())}/sdk` : "sdk";
+    this.#packageName = settings.name ? `@${spinalcase3(this.#clientName.toLowerCase())}/sdk` : "sdk";
   }
   succinct(entry, operation, values) {
     let payload = "{}";
@@ -2312,7 +2316,7 @@ var TypeScriptGenerator = class {
     };
   }
   #toRequest(entry, payload) {
-    return `await ${camelcase3(this.#clientName)}.request('${entry.method.toUpperCase()} ${entry.path}', ${payload});`;
+    return `await ${camelcase4(this.#clientName)}.request('${entry.method.toUpperCase()} ${entry.path}', ${payload});`;
   }
   snippet(entry, operation, config = {}) {
     const payload = this.succinct(entry, operation, config);
@@ -2353,7 +2357,7 @@ ${client.use}`;
   #constructClient(options = {}) {
     return {
       import: `import { ${this.#clientName} } from '${this.#packageName}';`,
-      use: `const ${camelcase3(this.#clientName)} = new ${this.#clientName}({
+      use: `const ${camelcase4(this.#clientName)} = new ${this.#clientName}({
 		${Object.entries(
         options
       ).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(",\n		")}
@@ -2888,7 +2892,7 @@ function availablePaginationTypes(spec) {
   let offset = false;
   let page = false;
   let cursor = false;
-  forEachOperation3(spec, (entry, operation) => {
+  forEachOperation4(spec, (entry, operation) => {
     if (operation["x-pagination"]) {
       switch (operation["x-pagination"].type) {
         case "offset":
@@ -2945,7 +2949,6 @@ async function generate(openapi, settings) {
     },
     false
   );
-  const generator = new TypeScriptGenerator(spec, settings);
   const style = Object.assign(
     {},
     {
@@ -2980,7 +2983,7 @@ async function generate(openapi, settings) {
     makeImport
   });
   const clientName = pascalcase5((settings.name || "client").trim());
-  const packageName = settings.name ? `@${spinalcase3(settings.name.trim().toLowerCase())}/sdk` : "sdk";
+  const packageName = settings.name ? `@${spinalcase4(settings.name.trim().toLowerCase())}/sdk` : "sdk";
   const inputs = toInputs(groups, commonZod, makeImport);
   const models = serializeModels(spec);
   await settings.writer(output, {
@@ -3082,8 +3085,9 @@ ${template2(dispatcher_default, {})({ throwError: !style.errorAsValue, outputTyp
   });
   if (settings.agentTools) {
     await settings.writer(output, {
-      "agents.ts": `${generateAgentTools(spec)}
+      "agents.ts": `${generateAISDKTools(spec)}
 ${utils_default}`
+      // 'agents.ts': `${generateOpenAIAgentTools(spec)}\n${utilsTxt}`,
     });
   }
   await settings.writer(output, {
@@ -3092,7 +3096,7 @@ ${utils_default}`
       settings.readFolder,
       settings.useTsExtension,
       ["ts"],
-      (config) => config.fileName.endsWith("pagination")
+      (config) => config.fileName.endsWith("pagination") || config.fileName.endsWith("agents")
     )
   });
   if (settings.mode === "full") {
@@ -3154,7 +3158,7 @@ ${utils_default}`
   }
   if (settings.readme) {
     await settings.writer(settings.mode === "full" ? settings.output : output, {
-      "README.md": toReadme(spec, generator)
+      "README.md": toReadme(spec, new TypeScriptSnippet(spec, settings))
     });
   }
   await settings.formatCode?.({
@@ -3188,7 +3192,7 @@ ${schema.description ? `
 ` : ""}`,
       `export type ${pascalcase5(sanitizeTag4(name))} = ${typeContent};`
     ];
-    const fileName = responseGroup ? join2(folder, `${spinalcase3(responseGroup)}.ts`) : join2(folder, `${spinalcase3(name)}.ts`);
+    const fileName = responseGroup ? join2(folder, `${spinalcase4(responseGroup)}.ts`) : join2(folder, `${spinalcase4(name)}.ts`);
     filesMap[fileName] ??= [];
     filesMap[fileName].push(fileContent.join("\n"));
   }
@@ -3209,18 +3213,18 @@ function toInputs(operationsSet, commonZod, makeImport) {
     const output = [];
     const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
     for (const operation of operations) {
-      const schemaName = camelcase4(`${operation.name} schema`);
+      const schemaName = camelcase5(`${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)) {
           imports.add(
-            `import { ${it} } from './schemas/${makeImport(spinalcase3(it))}';`
+            `import { ${it} } from './schemas/${makeImport(spinalcase4(it))}';`
           );
         }
       }
       output.push(schema);
     }
-    inputs[`inputs/${spinalcase3(name)}.ts`] = [...imports, ...output].join("\n") + "\n";
+    inputs[`inputs/${spinalcase4(name)}.ts`] = [...imports, ...output].join("\n") + "\n";
   }
   const schemas = commonZod.entries().reduce((acc, [name, schema]) => {
     const output = [`import { z } from 'zod';`];
@@ -3229,13 +3233,13 @@ function toInputs(operationsSet, commonZod, makeImport) {
       const preciseMatch = new RegExp(`\\b${schema2}\\b`);
       if (preciseMatch.test(content) && schema2 !== name) {
         output.push(
-          `import { ${schema2} } from './${makeImport(spinalcase3(schema2))}';`
+          `import { ${schema2} } from './${makeImport(spinalcase4(schema2))}';`
         );
       }
     }
     output.push(content);
     return [
-      [`inputs/schemas/${spinalcase3(name)}.ts`, output.join("\n")],
+      [`inputs/schemas/${spinalcase4(name)}.ts`, output.join("\n")],
       ...acc
     ];
   }, []);
@@ -3244,44 +3248,14 @@ function toInputs(operationsSet, commonZod, makeImport) {
     ...inputs
   };
 }
-function generateAgentTools(spec) {
-  const groups = {};
-  forEachOperation4(spec, (entry, operation) => {
-    groups[entry.tag] ??= [];
-    groups[entry.tag].push(createTool(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 ${spinalcase3(group)} = [${tools2.join(", ")}];`;
-  });
-  return [...imports, ...tools].join("\n\n");
-}
-function createTool(entry, operation) {
-  const schemaName = camelcase4(`${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);
-      },
-    })`;
-}
 export {
-  TypeScriptGenerator,
+  TypeScriptSnippet,
+  buildInput,
   generate,
-  generateAgentTools,
+  generateCode,
+  inputToPath,
+  toEndpoint,
+  toHttpOutput,
   toInputs
 };
 //# sourceMappingURL=index.js.map