@aprovan/stitchery 0.1.0-dev.ba8f277 → 0.1.0-dev.c680591

package/src/server/services.ts

@@ -8,7 +8,7 @@
  * Provides unified interface for calling services and exposing metadata.
  */
 
-import { jsonSchema, type Tool } from 'ai';
+import { jsonSchema, type Tool } from "ai";
 
 /**
  * Service backend interface - abstracts service call mechanisms
@@ -30,8 +30,10 @@ export interface ServiceToolInfo {
   procedure: string;
   /** Tool description */
   description?: string;
-  /** Parameter schema */
+  /** Parameter schema (inputs) */
   parameters?: Record<string, unknown>;
+  /** Response schema (outputs) */
+  outputs?: Record<string, unknown>;
   /** TypeScript interface definition (optional, for search results) */
   typescriptInterface?: string;
 }
@@ -70,7 +72,7 @@ export class ServiceRegistry {
       this.tools.set(name, tool);
 
       // Parse namespace and procedure from the full name using '.' separator
-      const dotIndex = name.indexOf('.');
+      const dotIndex = name.indexOf(".");
       const ns = dotIndex > 0 ? name.substring(0, dotIndex) : name;
       const procedure = dotIndex > 0 ? name.substring(dotIndex + 1) : name;
 
@@ -97,13 +99,22 @@ export class ServiceRegistry {
     this.backends.push(backend);
     if (toolInfos) {
       for (const info of toolInfos) {
-        this.toolInfo.set(info.name, info);
+        // Generate TypeScript interface including response type if outputs schema provided
+        const infoWithInterface: ServiceToolInfo = {
+          ...info,
+          typescriptInterface: this.generateTypeScriptInterfaceFromSchema(
+            info.name,
+            info.parameters,
+            info.outputs,
+          ),
+        };
+        this.toolInfo.set(info.name, infoWithInterface);
 
         // Create a callable Tool object for LLM use
         const tool: Tool = {
           description: info.description,
           inputSchema: jsonSchema(
-            info.parameters ?? { type: 'object', properties: {} },
+            info.parameters ?? { type: "object", properties: {} },
           ),
           execute: async (args: unknown) => {
             return backend.call(info.namespace, info.procedure, [args]);
@@ -119,34 +130,87 @@ export class ServiceRegistry {
    */
   private generateTypeScriptInterface(name: string, tool: Tool): string {
     const schema = tool.inputSchema as Record<string, unknown> | undefined;
-    const props = (schema?.properties ?? {}) as Record<
+    return this.generateTypeScriptInterfaceFromSchema(name, schema);
+  }
+
+  /**
+   * Convert JSON Schema type to TypeScript type
+   */
+  private schemaTypeToTs(schema: Record<string, unknown>): string {
+    const type = schema.type as string | undefined;
+    const items = schema.items as Record<string, unknown> | undefined;
+    const properties = schema.properties as
+      | Record<string, Record<string, unknown>>
+      | undefined;
+    const required = (schema.required ?? []) as string[];
+
+    if (type === "number" || type === "integer") return "number";
+    if (type === "boolean") return "boolean";
+    if (type === "null") return "null";
+    if (type === "array") {
+      if (items) {
+        return `${this.schemaTypeToTs(items)}[]`;
+      }
+      return "unknown[]";
+    }
+    if (type === "object" && properties) {
+      const props = Object.entries(properties)
+        .map(([key, val]) => {
+          const optional = !required.includes(key) ? "?" : "";
+          const propType = this.schemaTypeToTs(val);
+          return `${key}${optional}: ${propType}`;
+        })
+        .join("; ");
+      return `{ ${props} }`;
+    }
+    if (type === "object") return "Record<string, unknown>";
+    return "string";
+  }
+
+  /**
+   * Generate TypeScript interface from JSON Schema (supports both inputs and outputs)
+   */
+  private generateTypeScriptInterfaceFromSchema(
+    name: string,
+    inputSchema?: Record<string, unknown>,
+    outputSchema?: Record<string, unknown>,
+  ): string {
+    const safeName = name.replace(/[^a-zA-Z0-9]/g, "_");
+
+    // Generate Args interface
+    const inputProps = (inputSchema?.properties ?? {}) as Record<
       string,
       { type?: string; description?: string }
     >;
-    const required = (schema?.required ?? []) as string[];
+    const inputRequired = (inputSchema?.required ?? []) as string[];
 
-    const params = Object.entries(props)
+    const inputParams = Object.entries(inputProps)
       .map(([key, val]) => {
-        const optional = !required.includes(key) ? '?' : '';
+        const optional = !inputRequired.includes(key) ? "?" : "";
         const type =
-          val.type === 'number'
-            ? 'number'
-            : val.type === 'boolean'
-            ? 'boolean'
-            : val.type === 'array'
-            ? 'unknown[]'
-            : val.type === 'object'
-            ? 'Record<string, unknown>'
-            : 'string';
-        const comment = val.description ? ` // ${val.description}` : '';
+          val.type === "number"
+            ? "number"
+            : val.type === "boolean"
+              ? "boolean"
+              : val.type === "array"
+                ? "unknown[]"
+                : val.type === "object"
+                  ? "Record<string, unknown>"
+                  : "string";
+        const comment = val.description ? ` // ${val.description}` : "";
         return `  ${key}${optional}: ${type};${comment}`;
       })
-      .join('\n');
+      .join("\n");
 
-    return `interface ${name.replace(
-      /[^a-zA-Z0-9]/g,
-      '_',
-    )}Args {\n${params}\n}`;
+    let result = `interface ${safeName}Args {\n${inputParams}\n}`;
+
+    // Generate Response interface if outputs schema provided
+    if (outputSchema && Object.keys(outputSchema).length > 0) {
+      const responseType = this.schemaTypeToTs(outputSchema);
+      result += `\n\ntype ${safeName}Response = ${responseType};`;
+    }
+
+    return result;
   }
 
   /**
@@ -154,7 +218,7 @@ export class ServiceRegistry {
    * OpenAI-compatible APIs require tool names to match ^[a-zA-Z0-9_-]+$
    */
   private toLLMToolName(internalName: string): string {
-    return internalName.replace(/\./g, '_');
+    return internalName.replace(/\./g, "_");
   }
 
   /**
@@ -169,11 +233,11 @@ export class ServiceRegistry {
       }
     }
     // Fallback: convert first underscore to dot
-    const underscoreIndex = llmName.indexOf('_');
+    const underscoreIndex = llmName.indexOf("_");
     if (underscoreIndex > 0) {
       return (
         llmName.substring(0, underscoreIndex) +
-        '.' +
+        "." +
         llmName.substring(underscoreIndex + 1)
       );
     }
@@ -231,7 +295,7 @@ export class ServiceRegistry {
         .map((info) => {
           const searchText = `${info.name} ${info.namespace} ${
             info.procedure
-          } ${info.description ?? ''}`.toLowerCase();
+          } ${info.description ?? ""}`.toLowerCase();
           const matchCount = keywords.filter((kw) =>
             searchText.includes(kw),
           ).length;
@@ -304,7 +368,7 @@ export class ServiceRegistry {
           this.tools.keys(),
         )
           .slice(0, 10)
-          .join(', ')}`,
+          .join(", ")}`,
       );
     }
 
@@ -342,7 +406,7 @@ export class ServiceRegistry {
  */
 export function generateServicesPrompt(registry: ServiceRegistry): string {
   const namespaces = registry.getNamespaces();
-  if (namespaces.length === 0) return '';
+  if (namespaces.length === 0) return "";
 
   const services = registry.getServiceInfo();
   const byNamespace = new Map<string, ServiceToolInfo[]>();
@@ -353,7 +417,7 @@ export function generateServicesPrompt(registry: ServiceRegistry): string {
     byNamespace.set(service.namespace, existing);
   }
 
-  let prompt = `## Available Services\n\nThe following services are available for generated widgets to call:\n\n`;
+  let prompt = `## Services\n\nThe following services are available for generated widgets to call:\n\n`;
 
   for (const [ns, tools] of byNamespace) {
     prompt += `### \`${ns}\`\n`;
@@ -362,16 +426,16 @@ export function generateServicesPrompt(registry: ServiceRegistry): string {
       if (tool.description) {
         prompt += `: ${tool.description}`;
       }
-      prompt += '\n';
+      prompt += "\n";
     }
-    prompt += '\n';
+    prompt += "\n";
   }
 
   prompt += `**Usage in widgets:**
 \`\`\`tsx
 // Services are available as global namespaces
-const result = await ${namespaces[0] ?? 'service'}.${
-    byNamespace.get(namespaces[0] ?? '')?.[0]?.procedure ?? 'example'
+const result = await ${namespaces[0] ?? "service"}.${
+    byNamespace.get(namespaces[0] ?? "")?.[0]?.procedure ?? "example"
   }({ /* args */ });
 \`\`\`
 

package/src/server/vfs-routes.ts

@@ -40,7 +40,7 @@ async function listAllFiles(
   relPath: string,
 ): Promise<string[]> {
   const targetPath = resolvePath(rootDir, relPath);
-  let entries: Awaited<ReturnType<typeof readdir>> = [];
+  let entries;
   try {
     entries = await readdir(targetPath, { withFileTypes: true });
   } catch {
@@ -49,7 +49,7 @@ async function listAllFiles(
 
   const results: string[] = [];
   for (const entry of entries) {
-    const entryRelPath = joinRelPath(relPath, entry.name);
+    const entryRelPath = joinRelPath(relPath, String(entry.name));
     if (entry.isDirectory()) {
       results.push(...(await listAllFiles(rootDir, entryRelPath)));
     } else {