@standardagents/builder 0.11.0-next.c3b4490 → 0.11.1

package/dist/index.d.ts

@@ -13,63 +13,71 @@ import 'vite';
  * Types are automatically populated when you run `pnpm dev` or `pnpm build`,
  * which scans your `agentbuilder/` directories and generates types.
  *
- * The generated types are placed in `.agentbuilder/types.d.ts` and augment this namespace.
+ * The generated types are placed in `.agents/types.d.ts` and augment the
+ * StandardAgentSpec namespace from @standardagents/spec.
  *
- * Note: We use interfaces as type registries because TypeScript allows interface
- * declaration merging. The user's generated types will add properties to these
- * interfaces, and we extract the union of all property keys.
+ * Note: This namespace is provided for backward compatibility. New code should
+ * use StandardAgentSpec types directly, which are defined in @standardagents/spec.
+ *
+ * @deprecated Use StandardAgentSpec namespace from @standardagents/spec instead
  */
 declare global {
     namespace AgentBuilder {
         /**
          * Interface for model type registration.
-         * Generated types add properties: interface ModelRegistry { 'gpt-4o': true; 'claude-3': true; }
-         * This gives us: type Models = keyof ModelRegistry = 'gpt-4o' | 'claude-3'
+         * @deprecated Use StandardAgentSpec.ModelRegistry instead
          */
-        interface ModelRegistry {
+        interface ModelRegistry extends StandardAgentSpec.ModelRegistry {
         }
         /**
          * Interface for prompt type registration.
+         * @deprecated Use StandardAgentSpec.PromptRegistry instead
          */
-        interface PromptRegistry {
+        interface PromptRegistry extends StandardAgentSpec.PromptRegistry {
         }
         /**
          * Interface for agent type registration.
+         * @deprecated Use StandardAgentSpec.AgentRegistry instead
          */
-        interface AgentRegistry {
+        interface AgentRegistry extends StandardAgentSpec.AgentRegistry {
         }
         /**
          * Interface for tool type registration.
+         * @deprecated Use StandardAgentSpec.ToolRegistry instead
          */
-        interface ToolRegistry {
+        interface ToolRegistry extends StandardAgentSpec.ToolRegistry {
         }
         /**
          * Interface for callable type registration (prompts, agents, tools).
+         * @deprecated Use StandardAgentSpec.CallableRegistry instead
          */
-        interface CallableRegistry {
+        interface CallableRegistry extends StandardAgentSpec.CallableRegistry {
         }
         /**
          * Union type of all model names defined in agentbuilder/models/.
-         * When ModelRegistry is empty, this defaults to string for flexibility.
-         * When populated, it narrows to the specific model names.
+         * @deprecated Use StandardAgentSpec.Models instead
          */
-        type Models = keyof ModelRegistry extends never ? string : keyof ModelRegistry;
+        type Models = StandardAgentSpec.Models;
         /**
          * Union type of all prompt names defined in agentbuilder/prompts/.
+         * @deprecated Use StandardAgentSpec.Prompts instead
          */
-        type Prompts = keyof PromptRegistry extends never ? string : keyof PromptRegistry;
+        type Prompts = StandardAgentSpec.Prompts;
         /**
          * Union type of all agent names defined in agentbuilder/agents/.
+         * @deprecated Use StandardAgentSpec.Agents instead
          */
-        type Agents = keyof AgentRegistry extends never ? string : keyof AgentRegistry;
+        type Agents = StandardAgentSpec.Agents;
         /**
          * Union type of all tool names defined in agentbuilder/tools/.
+         * @deprecated Use StandardAgentSpec.Tools instead
          */
-        type Tools = keyof ToolRegistry extends never ? string : keyof ToolRegistry;
+        type Tools = StandardAgentSpec.Tools;
         /**
          * Union type of all callable items (prompts, agents, tools) that can be used as tools.
+         * @deprecated Use StandardAgentSpec.Callables instead
          */
-        type Callables = keyof CallableRegistry extends never ? string : keyof CallableRegistry;
+        type Callables = StandardAgentSpec.Callables;
     }
 }
 
@@ -273,7 +281,8 @@ interface ThreadInstance {
     loadAgent(name: string): Promise<any>;
     getPromptNames(): string[];
     getAgentNames(): string[];
-    writeFile(path: string, data: ArrayBuffer | string, mimeType: string, options?: Record<string, unknown>): Promise<any>;
+    writeFile(path: string, data: string, mimeType: string, options?: Record<string, unknown>): Promise<any>;
+    writeTextFile(path: string, content: string, mimeType: string, options?: Record<string, unknown>): Promise<any>;
     readFile(path: string): Promise<{
         success: boolean;
         data?: string;

package/dist/index.js

@@ -2212,8 +2212,105 @@ var init_ThreadStateImpl = __esm({
       // File System
       // ─────────────────────────────────────────────────────────────────────────
       async writeFile(path4, data, mimeType, options) {
-        const result = await this._threadInstance.writeFile(path4, data, mimeType, options);
-        return this._mapFileRecord(result);
+        const isText = this._isTextMimeType(mimeType);
+        if (isText) {
+          let textContent;
+          if (typeof data === "string") {
+            textContent = data;
+          } else {
+            textContent = new TextDecoder().decode(data);
+          }
+          const result = await this._threadInstance.writeTextFile(path4, textContent, mimeType, options);
+          return this._mapFileRecord(result.file);
+        } else {
+          let base64Data;
+          if (typeof data === "string") {
+            const encoder = new TextEncoder();
+            const bytes = encoder.encode(data);
+            let binary = "";
+            for (let i = 0; i < bytes.length; i++) {
+              binary += String.fromCharCode(bytes[i]);
+            }
+            base64Data = btoa(binary);
+          } else {
+            const bytes = new Uint8Array(data);
+            let binary = "";
+            for (let i = 0; i < bytes.length; i++) {
+              binary += String.fromCharCode(bytes[i]);
+            }
+            base64Data = btoa(binary);
+          }
+          const result = await this._threadInstance.writeFile(path4, base64Data, mimeType, options);
+          return this._mapFileRecord(result.file);
+        }
+      }
+      /**
+       * Check if a MIME type should be stored as searchable text.
+       * Matches the logic in FileStorage for consistency.
+       */
+      _isTextMimeType(mimeType) {
+        if (mimeType.startsWith("text/")) return true;
+        const TEXT_APPLICATION_TYPES2 = [
+          // Data formats
+          "application/json",
+          "application/ld+json",
+          "application/json5",
+          "application/jsonl",
+          "application/x-ndjson",
+          "application/xml",
+          "application/xhtml+xml",
+          "application/rss+xml",
+          "application/atom+xml",
+          "application/soap+xml",
+          "application/yaml",
+          "application/x-yaml",
+          "application/toml",
+          "application/x-toml",
+          // Programming languages
+          "application/javascript",
+          "application/x-javascript",
+          "application/ecmascript",
+          "application/typescript",
+          "application/x-typescript",
+          "application/x-python",
+          "application/x-ruby",
+          "application/x-perl",
+          "application/x-php",
+          "application/x-sh",
+          "application/x-bash",
+          "application/x-csh",
+          "application/x-zsh",
+          "application/x-powershell",
+          "application/x-lua",
+          "application/x-tcl",
+          // Query/config languages
+          "application/sql",
+          "application/x-sql",
+          "application/graphql",
+          "application/x-graphql",
+          "application/sparql-query",
+          "application/sparql-results+json",
+          "application/sparql-results+xml",
+          // Markup/templates
+          "application/x-httpd-php",
+          "application/x-latex",
+          "application/x-tex",
+          "application/rtf",
+          "application/xslt+xml",
+          // Web
+          "application/x-www-form-urlencoded",
+          "application/manifest+json",
+          "application/webmanifest+json",
+          "application/x-web-app-manifest+json",
+          // Config files
+          "application/x-ini",
+          "application/x-properties",
+          "application/plist",
+          "application/x-plist"
+        ];
+        return TEXT_APPLICATION_TYPES2.some(
+          (type) => mimeType === type || mimeType.startsWith(type + ";")
+        );
       }
       async readFile(path4) {
         const result = await this._threadInstance.readFile(path4);
@@ -2476,7 +2573,10 @@ __export(files_exports, {
   rowToFileRecord: () => rowToFileRecord
 });
 function isTextMimeType(mimeType) {
-  return TEXT_MIME_TYPES.some((prefix) => mimeType.startsWith(prefix));
+  if (mimeType.startsWith("text/")) return true;
+  return TEXT_APPLICATION_TYPES.some(
+    (type) => mimeType === type || mimeType.startsWith(type + ";")
+  );
 }
 function detectStorageBackend(location) {
   if (location.startsWith("s3://")) return "s3";
@@ -2553,17 +2653,67 @@ function inferMimeType(filename) {
   };
   return mimeTypes[ext || ""] || "application/octet-stream";
 }
-var CHUNK_SIZE, TEXT_MIME_TYPES, FileStorage;
+var CHUNK_SIZE, TEXT_APPLICATION_TYPES, FileStorage;
 var init_files = __esm({
   "src/durable-objects/files.ts"() {
     CHUNK_SIZE = 1.75 * 1024 * 1024;
-    TEXT_MIME_TYPES = [
-      "text/",
+    TEXT_APPLICATION_TYPES = [
+      // Data formats
       "application/json",
-      "application/javascript",
+      "application/ld+json",
+      "application/json5",
+      "application/jsonl",
+      "application/x-ndjson",
       "application/xml",
+      "application/xhtml+xml",
+      "application/rss+xml",
+      "application/atom+xml",
+      "application/soap+xml",
+      "application/yaml",
       "application/x-yaml",
-      "application/yaml"
+      "application/toml",
+      "application/x-toml",
+      // Programming languages
+      "application/javascript",
+      "application/x-javascript",
+      "application/ecmascript",
+      "application/typescript",
+      "application/x-typescript",
+      "application/x-python",
+      "application/x-ruby",
+      "application/x-perl",
+      "application/x-php",
+      "application/x-sh",
+      "application/x-bash",
+      "application/x-csh",
+      "application/x-zsh",
+      "application/x-powershell",
+      "application/x-lua",
+      "application/x-tcl",
+      // Query/config languages
+      "application/sql",
+      "application/x-sql",
+      "application/graphql",
+      "application/x-graphql",
+      "application/sparql-query",
+      "application/sparql-results+json",
+      "application/sparql-results+xml",
+      // Markup/templates
+      "application/x-httpd-php",
+      "application/x-latex",
+      "application/x-tex",
+      "application/rtf",
+      "application/xslt+xml",
+      // Web
+      "application/x-www-form-urlencoded",
+      "application/manifest+json",
+      "application/webmanifest+json",
+      "application/x-web-app-manifest+json",
+      // Config files
+      "application/x-ini",
+      "application/x-properties",
+      "application/plist",
+      "application/x-plist"
     ];
     FileStorage = class {
       constructor(sql) {
@@ -7521,18 +7671,18 @@ function generateTypesContent(config) {
   return `// Auto-generated by @standardagents/builder - DO NOT EDIT
 // Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
 //
-// This file augments the AgentBuilder namespace declared in @standardagents/builder
+// This file augments the StandardAgentSpec namespace declared in @standardagents/spec
 // to provide type-safe references for your models, prompts, agents, and tools.
 
 /**
- * Augment the global AgentBuilder namespace with your project's specific types.
+ * Augment the global StandardAgentSpec namespace with your project's specific types.
  * This provides autocomplete and type checking for model, prompt, agent, and tool references.
  *
  * Uses interface declaration merging with property keys to create union types.
  * Example: interface ModelRegistry { 'gpt-4o': true; } gives type Models = 'gpt-4o'
  */
 declare global {
-  namespace AgentBuilder {
+  namespace StandardAgentSpec {
     /** Model names from agents/models/ */
     interface ModelRegistry {
       ${generateRegistryProperties(models)}
@@ -8120,7 +8270,7 @@ function parseModelFile(content) {
 function generateModelFile(data, options) {
   const { providerName, providerPackage } = options;
   const lines = [
-    `import { defineModel } from '@standardagents/builder';`,
+    `import { defineModel } from '@standardagents/spec';`,
     `import { ${providerName} } from '${providerPackage}';`,
     "",
     `export default defineModel({`,
@@ -8354,7 +8504,7 @@ function isEmptySchema(schema) {
 // src/sdk/generators/generatePromptFile.ts
 function generatePromptFile(data) {
   const hasSchema = data.requiredSchema && !isEmptySchema(data.requiredSchema);
-  const lines = [`import { definePrompt } from '@standardagents/builder';`];
+  const lines = [`import { definePrompt } from '@standardagents/spec';`];
   if (hasSchema) {
     lines.push(`import { z } from 'zod';`);
   }
@@ -8544,7 +8694,7 @@ function normalizePart(part) {
 // src/sdk/generators/generateAgentFile.ts
 function generateAgentFile(data) {
   const lines = [
-    `import { defineAgent } from '@standardagents/builder';`,
+    `import { defineAgent } from '@standardagents/spec';`,
     "",
     `export default defineAgent({`,
     `  name: '${escapeString3(data.name)}',`