sparkecoder 0.1.60 → 0.1.61

package/dist/agent/index.js

@@ -8,6 +8,191 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/config/types.ts
+import { z } from "zod";
+var ToolApprovalConfigSchema, SkillMetadataSchema, TaskConfigSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
+var init_types = __esm({
+  "src/config/types.ts"() {
+    "use strict";
+    ToolApprovalConfigSchema = z.object({
+      bash: z.boolean().optional().default(true),
+      write_file: z.boolean().optional().default(false),
+      read_file: z.boolean().optional().default(false),
+      load_skill: z.boolean().optional().default(false),
+      todo: z.boolean().optional().default(false)
+    });
+    SkillMetadataSchema = z.object({
+      name: z.string(),
+      description: z.string(),
+      // Whether to always inject this skill into context (vs on-demand loading)
+      alwaysApply: z.boolean().optional().default(false),
+      // Glob patterns - auto-inject when working with matching files
+      globs: z.array(z.string()).optional().default([])
+    });
+    TaskConfigSchema = z.object({
+      enabled: z.boolean(),
+      outputSchema: z.record(z.string(), z.unknown()),
+      webhookUrl: z.string().url().optional(),
+      maxIterations: z.number().optional(),
+      status: z.enum(["running", "completed", "failed"]),
+      result: z.unknown().optional(),
+      error: z.string().optional(),
+      iterations: z.number().optional()
+    });
+    SessionConfigSchema = z.object({
+      toolApprovals: z.record(z.string(), z.boolean()).optional(),
+      approvalWebhook: z.string().url().optional(),
+      skillsDirectory: z.string().optional(),
+      maxContextChars: z.number().optional().default(2e5),
+      task: TaskConfigSchema.optional()
+    });
+    VectorGatewayConfigSchema = z.object({
+      // Redis cluster nodes URL for Vector Gateway (or use REDIS_CLUSTER_NODES env var)
+      redisUrl: z.string().optional(),
+      // HTTP URL for database operations (or use VECTOR_HTTP_URL env var)
+      httpUrl: z.string().optional(),
+      // Embedding model to use (default: text-embedding-3-small)
+      embeddingModel: z.string().default("gemini-embedding-001"),
+      // Custom namespace override (auto-generated from git remote if not set)
+      namespace: z.string().optional(),
+      // File patterns to include in indexing
+      include: z.array(z.string()).optional().default([
+        "**/*.ts",
+        "**/*.tsx",
+        "**/*.js",
+        "**/*.jsx",
+        "**/*.py",
+        "**/*.go",
+        "**/*.rs",
+        "**/*.java",
+        "**/*.md",
+        "**/*.mdx",
+        "**/*.txt"
+      ]),
+      // File patterns to exclude from indexing
+      exclude: z.array(z.string()).optional().default([
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/.git/**",
+        "**/.next/**",
+        "**/*.min.js",
+        "**/*.bundle.js",
+        "**/pnpm-lock.yaml",
+        "**/package-lock.json",
+        "**/yarn.lock",
+        "**/.test-workspace/**",
+        "**/.semantic-test-workspace/**",
+        "**/.semantic-integration-test/**"
+      ])
+    }).optional();
+    RemoteServerConfigSchema = z.object({
+      // URL of the remote server (e.g., https://agent.sparkecode.com)
+      url: z.string().url().optional(),
+      // Auth key for the remote server (auto-generated on first use if not set)
+      // Can also be set via SPARKECODER_AUTH_KEY env var
+      authKey: z.string().optional()
+    }).optional();
+    SparkcoderConfigSchema = z.object({
+      // Default model to use (Vercel AI Gateway format)
+      defaultModel: z.string().default("anthropic/claude-opus-4-6"),
+      // Working directory for file operations
+      workingDirectory: z.string().optional(),
+      // Tool approval settings
+      toolApprovals: ToolApprovalConfigSchema.optional().default({}),
+      // Approval webhook URL (called when approval is needed)
+      approvalWebhook: z.string().url().optional(),
+      // Skills configuration
+      skills: z.object({
+        // Directory containing skill files
+        directory: z.string().optional().default("./skills"),
+        // Additional skill directories to include
+        additionalDirectories: z.array(z.string()).optional().default([])
+      }).optional().default({}),
+      // Context management
+      context: z.object({
+        // Maximum context size before summarization (in characters)
+        maxChars: z.number().optional().default(2e5),
+        // Enable automatic summarization
+        autoSummarize: z.boolean().optional().default(true),
+        // Number of recent messages to keep after summarization
+        keepRecentMessages: z.number().optional().default(10)
+      }).optional().default({}),
+      // Server configuration
+      server: z.object({
+        port: z.number().default(3141),
+        host: z.string().default("127.0.0.1"),
+        // Public URL for web UI to connect to API (for Docker/remote access)
+        // If not set, defaults to http://{host}:{port}
+        publicUrl: z.string().url().optional()
+      }).default({ port: 3141, host: "127.0.0.1" }),
+      // Database path (used for local SQLite - ignored if remoteServer is configured)
+      databasePath: z.string().optional().default("./sparkecoder.db"),
+      // Remote server configuration (for centralized storage)
+      // If configured, uses remote MongoDB instead of local SQLite
+      remoteServer: RemoteServerConfigSchema,
+      // Vector Gateway configuration for semantic search
+      vectorGateway: VectorGatewayConfigSchema
+    });
+  }
+});
+
+// src/config/index.ts
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir, platform } from "os";
+function getAppDataDirectory() {
+  const appName = "sparkecoder";
+  switch (platform()) {
+    case "darwin":
+      return join(homedir(), "Library", "Application Support", appName);
+    case "win32":
+      return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), appName);
+    default:
+      return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), appName);
+  }
+}
+function getConfig() {
+  if (!cachedConfig) {
+    throw new Error("Config not loaded. Call loadConfig first.");
+  }
+  return cachedConfig;
+}
+function requiresApproval(toolName, sessionConfig) {
+  const config = getConfig();
+  if (sessionConfig?.toolApprovals?.["*"] !== void 0) {
+    return sessionConfig.toolApprovals["*"];
+  }
+  if (sessionConfig?.toolApprovals?.[toolName] !== void 0) {
+    return sessionConfig.toolApprovals[toolName];
+  }
+  const globalApprovals = config.toolApprovals;
+  if (globalApprovals[toolName] !== void 0) {
+    return globalApprovals[toolName];
+  }
+  if (toolName === "bash") {
+    return true;
+  }
+  return false;
+}
+var cachedConfig, PROVIDER_ENV_MAP, SUPPORTED_PROVIDERS;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_types();
+    init_types();
+    cachedConfig = null;
+    PROVIDER_ENV_MAP = {
+      anthropic: "ANTHROPIC_API_KEY",
+      openai: "OPENAI_API_KEY",
+      google: "GOOGLE_GENERATIVE_AI_API_KEY",
+      xai: "XAI_API_KEY",
+      "ai-gateway": "AI_GATEWAY_API_KEY"
+    };
+    SUPPORTED_PROVIDERS = Object.keys(PROVIDER_ENV_MAP);
+  }
+});
+
 // src/db/remote.ts
 function parseDates(obj) {
   if (obj === null || obj === void 0) return obj;
@@ -298,177 +483,6 @@ var init_db = __esm({
   }
 });
 
-// src/config/types.ts
-import { z } from "zod";
-var ToolApprovalConfigSchema, SkillMetadataSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
-var init_types = __esm({
-  "src/config/types.ts"() {
-    "use strict";
-    ToolApprovalConfigSchema = z.object({
-      bash: z.boolean().optional().default(true),
-      write_file: z.boolean().optional().default(false),
-      read_file: z.boolean().optional().default(false),
-      load_skill: z.boolean().optional().default(false),
-      todo: z.boolean().optional().default(false)
-    });
-    SkillMetadataSchema = z.object({
-      name: z.string(),
-      description: z.string(),
-      // Whether to always inject this skill into context (vs on-demand loading)
-      alwaysApply: z.boolean().optional().default(false),
-      // Glob patterns - auto-inject when working with matching files
-      globs: z.array(z.string()).optional().default([])
-    });
-    SessionConfigSchema = z.object({
-      toolApprovals: z.record(z.string(), z.boolean()).optional(),
-      approvalWebhook: z.string().url().optional(),
-      skillsDirectory: z.string().optional(),
-      maxContextChars: z.number().optional().default(2e5)
-    });
-    VectorGatewayConfigSchema = z.object({
-      // Redis cluster nodes URL for Vector Gateway (or use REDIS_CLUSTER_NODES env var)
-      redisUrl: z.string().optional(),
-      // HTTP URL for database operations (or use VECTOR_HTTP_URL env var)
-      httpUrl: z.string().optional(),
-      // Embedding model to use (default: text-embedding-3-small)
-      embeddingModel: z.string().default("gemini-embedding-001"),
-      // Custom namespace override (auto-generated from git remote if not set)
-      namespace: z.string().optional(),
-      // File patterns to include in indexing
-      include: z.array(z.string()).optional().default([
-        "**/*.ts",
-        "**/*.tsx",
-        "**/*.js",
-        "**/*.jsx",
-        "**/*.py",
-        "**/*.go",
-        "**/*.rs",
-        "**/*.java",
-        "**/*.md",
-        "**/*.mdx",
-        "**/*.txt"
-      ]),
-      // File patterns to exclude from indexing
-      exclude: z.array(z.string()).optional().default([
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.git/**",
-        "**/.next/**",
-        "**/*.min.js",
-        "**/*.bundle.js",
-        "**/pnpm-lock.yaml",
-        "**/package-lock.json",
-        "**/yarn.lock",
-        "**/.test-workspace/**",
-        "**/.semantic-test-workspace/**",
-        "**/.semantic-integration-test/**"
-      ])
-    }).optional();
-    RemoteServerConfigSchema = z.object({
-      // URL of the remote server (e.g., https://agent.sparkecode.com)
-      url: z.string().url().optional(),
-      // Auth key for the remote server (auto-generated on first use if not set)
-      // Can also be set via SPARKECODER_AUTH_KEY env var
-      authKey: z.string().optional()
-    }).optional();
-    SparkcoderConfigSchema = z.object({
-      // Default model to use (Vercel AI Gateway format)
-      defaultModel: z.string().default("anthropic/claude-opus-4-6"),
-      // Working directory for file operations
-      workingDirectory: z.string().optional(),
-      // Tool approval settings
-      toolApprovals: ToolApprovalConfigSchema.optional().default({}),
-      // Approval webhook URL (called when approval is needed)
-      approvalWebhook: z.string().url().optional(),
-      // Skills configuration
-      skills: z.object({
-        // Directory containing skill files
-        directory: z.string().optional().default("./skills"),
-        // Additional skill directories to include
-        additionalDirectories: z.array(z.string()).optional().default([])
-      }).optional().default({}),
-      // Context management
-      context: z.object({
-        // Maximum context size before summarization (in characters)
-        maxChars: z.number().optional().default(2e5),
-        // Enable automatic summarization
-        autoSummarize: z.boolean().optional().default(true),
-        // Number of recent messages to keep after summarization
-        keepRecentMessages: z.number().optional().default(10)
-      }).optional().default({}),
-      // Server configuration
-      server: z.object({
-        port: z.number().default(3141),
-        host: z.string().default("127.0.0.1"),
-        // Public URL for web UI to connect to API (for Docker/remote access)
-        // If not set, defaults to http://{host}:{port}
-        publicUrl: z.string().url().optional()
-      }).default({ port: 3141, host: "127.0.0.1" }),
-      // Database path (used for local SQLite - ignored if remoteServer is configured)
-      databasePath: z.string().optional().default("./sparkecoder.db"),
-      // Remote server configuration (for centralized storage)
-      // If configured, uses remote MongoDB instead of local SQLite
-      remoteServer: RemoteServerConfigSchema,
-      // Vector Gateway configuration for semantic search
-      vectorGateway: VectorGatewayConfigSchema
-    });
-  }
-});
-
-// src/config/index.ts
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
-import { resolve, dirname, join } from "path";
-import { homedir, platform } from "os";
-function getAppDataDirectory() {
-  const appName = "sparkecoder";
-  switch (platform()) {
-    case "darwin":
-      return join(homedir(), "Library", "Application Support", appName);
-    case "win32":
-      return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), appName);
-    default:
-      return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), appName);
-  }
-}
-function getConfig() {
-  if (!cachedConfig) {
-    throw new Error("Config not loaded. Call loadConfig first.");
-  }
-  return cachedConfig;
-}
-function requiresApproval(toolName, sessionConfig) {
-  const config = getConfig();
-  if (sessionConfig?.toolApprovals?.[toolName] !== void 0) {
-    return sessionConfig.toolApprovals[toolName];
-  }
-  const globalApprovals = config.toolApprovals;
-  if (globalApprovals[toolName] !== void 0) {
-    return globalApprovals[toolName];
-  }
-  if (toolName === "bash") {
-    return true;
-  }
-  return false;
-}
-var cachedConfig, PROVIDER_ENV_MAP, SUPPORTED_PROVIDERS;
-var init_config = __esm({
-  "src/config/index.ts"() {
-    "use strict";
-    init_types();
-    init_types();
-    cachedConfig = null;
-    PROVIDER_ENV_MAP = {
-      anthropic: "ANTHROPIC_API_KEY",
-      openai: "OPENAI_API_KEY",
-      google: "GOOGLE_GENERATIVE_AI_API_KEY",
-      xai: "XAI_API_KEY",
-      "ai-gateway": "AI_GATEWAY_API_KEY"
-    };
-    SUPPORTED_PROVIDERS = Object.keys(PROVIDER_ENV_MAP);
-  }
-});
-
 // src/skills/index.ts
 var skills_exports = {};
 __export(skills_exports, {
@@ -1210,18 +1224,176 @@ var init_semantic_search = __esm({
 import {
   streamText as streamText2,
   generateText as generateText3,
-  tool as tool11,
+  tool as tool12,
   stepCountIs as stepCountIs2
 } from "ai";
 
 // src/agent/model.ts
 import { gateway } from "@ai-sdk/gateway";
+
+// src/agent/remote-model.ts
+function serializePrompt(prompt) {
+  return prompt.map((msg) => {
+    if (!Array.isArray(msg.content)) return msg;
+    return {
+      ...msg,
+      content: msg.content.map((part) => {
+        if (part.type === "file" && part.data instanceof Uint8Array) {
+          return {
+            ...part,
+            data: Buffer.from(part.data).toString("base64"),
+            _base64: true
+          };
+        }
+        return part;
+      })
+    };
+  });
+}
+function deserializeValue(value) {
+  if (value && typeof value === "object") {
+    if (value.__uint8array && typeof value.data === "string") {
+      return Buffer.from(value.data, "base64");
+    }
+    if (Array.isArray(value)) {
+      return value.map(deserializeValue);
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = deserializeValue(v);
+    }
+    return result;
+  }
+  return value;
+}
+function prepareOptions(options) {
+  const { abortSignal, ...rest } = options;
+  return {
+    ...rest,
+    prompt: serializePrompt(options.prompt)
+  };
+}
+function createRemoteModel(modelId, config) {
+  const baseUrl = config.url.replace(/\/$/, "");
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${config.authKey}`
+  };
+  return {
+    specificationVersion: "v3",
+    provider: "remote-proxy",
+    modelId,
+    supportedUrls: {},
+    async doGenerate(options) {
+      const res = await fetch(`${baseUrl}/inference/generate`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelId,
+          options: prepareOptions(options)
+        }),
+        signal: options.abortSignal
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(
+          `Remote inference failed (${res.status}): ${err.error || res.statusText}`
+        );
+      }
+      const result = await res.json();
+      return deserializeValue(result);
+    },
+    async doStream(options) {
+      const res = await fetch(`${baseUrl}/inference/stream`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          modelId,
+          options: prepareOptions(options)
+        }),
+        signal: options.abortSignal
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(
+          `Remote inference failed (${res.status}): ${err.error || res.statusText}`
+        );
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const stream = new ReadableStream({
+        async pull(controller) {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (buffer.trim()) {
+                try {
+                  const parsed = deserializeValue(JSON.parse(buffer.trim()));
+                  if (parsed.type === "error") {
+                    controller.error(new Error(parsed.error));
+                  } else {
+                    controller.enqueue(parsed);
+                  }
+                } catch {
+                }
+              }
+              controller.close();
+              return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                const parsed = deserializeValue(JSON.parse(line));
+                if (parsed.type === "error") {
+                  controller.error(new Error(parsed.error));
+                  return;
+                }
+                controller.enqueue(parsed);
+              } catch {
+              }
+            }
+          }
+        },
+        cancel() {
+          reader.cancel();
+        }
+      });
+      const responseHeaders = {};
+      res.headers.forEach((v, k) => {
+        if (k.startsWith("x-upstream-")) {
+          responseHeaders[k.replace("x-upstream-", "")] = v;
+        }
+      });
+      return {
+        stream,
+        response: Object.keys(responseHeaders).length > 0 ? { headers: responseHeaders } : void 0
+      };
+    }
+  };
+}
+
+// src/agent/model.ts
+init_config();
 var ANTHROPIC_PREFIX = "anthropic/";
 function isAnthropicModel(modelId) {
   const normalized = modelId.trim().toLowerCase();
   return normalized.startsWith(ANTHROPIC_PREFIX) || normalized.startsWith("claude-");
 }
 function resolveModel(modelId) {
+  try {
+    const config = getConfig();
+    if (config.resolvedRemoteServer.isConfigured) {
+      return createRemoteModel(modelId.trim(), {
+        url: config.resolvedRemoteServer.url,
+        authKey: config.resolvedRemoteServer.authKey
+      });
+    }
+  } catch {
+  }
   return gateway(modelId.trim());
 }
 var SUBAGENT_MODELS = {
@@ -1233,7 +1405,7 @@ var SUBAGENT_MODELS = {
 // src/agent/index.ts
 init_db();
 init_config();
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 import { nanoid as nanoid3 } from "nanoid";
 
 // src/tools/bash.ts
@@ -4359,6 +4531,59 @@ Context: ${context}` : query;
 
 // src/tools/index.ts
 init_semantic_search();
+
+// src/tools/task.ts
+import { tool as tool11 } from "ai";
+import { z as z12 } from "zod";
+import Ajv from "ajv";
+var ajv = new Ajv({ allErrors: true });
+function createCompleteTaskTool(options) {
+  const validate = ajv.compile(options.outputSchema);
+  return tool11({
+    description: "Call this tool when you have completed the task. Pass the result as a JSON object matching the required output schema. If the result does not match the schema, you will receive validation errors and should fix and retry.",
+    inputSchema: z12.object({
+      result: z12.record(z12.string(), z12.unknown()).describe("The task result as a JSON object matching the output schema")
+    }),
+    execute: async (input) => {
+      const valid = validate(input.result);
+      if (!valid) {
+        const errors = validate.errors?.map((e) => ({
+          path: e.instancePath || "/",
+          message: e.message,
+          params: e.params
+        }));
+        return {
+          status: "validation_error",
+          message: "The result does not match the required output schema. Fix the errors and call complete_task again.",
+          errors,
+          expectedSchema: options.outputSchema
+        };
+      }
+      options.onComplete({ status: "completed", result: input.result });
+      return {
+        status: "completed",
+        message: "Task completed successfully."
+      };
+    }
+  });
+}
+function createTaskFailedTool(options) {
+  return tool11({
+    description: "Call this tool if you are unable to complete the task. Provide a clear reason explaining why the task cannot be completed.",
+    inputSchema: z12.object({
+      reason: z12.string().describe("Explanation of why the task cannot be completed")
+    }),
+    execute: async (input) => {
+      options.onComplete({ status: "failed", error: input.reason });
+      return {
+        status: "failed",
+        message: `Task marked as failed: ${input.reason}`
+      };
+    }
+  });
+}
+
+// src/tools/index.ts
 init_semantic();
 init_semantic_search();
 async function createTools(options) {
@@ -4410,6 +4635,10 @@ async function createTools(options) {
     } catch {
     }
   }
+  if (options.taskTools) {
+    tools.complete_task = createCompleteTaskTool(options.taskTools);
+    tools.task_failed = createTaskFailedTool(options.taskTools);
+  }
   return tools;
 }
 
@@ -4727,6 +4956,30 @@ function formatTodosForContext(todos) {
   }
   return lines.join("\n");
 }
+function buildTaskPromptAddendum(outputSchema) {
+  return `
+## Task Mode
+
+You are running in **task mode**. You have been given a specific task to complete autonomously.
+
+### Rules
+1. Work independently \u2014 no human will approve tool calls. All tools run without approval.
+2. Keep working until the task is fully complete.
+3. When done, call the \`complete_task\` tool with a JSON result matching the output schema below.
+4. If you determine the task is impossible or encounter an unrecoverable error, call the \`task_failed\` tool with a clear reason.
+5. Do NOT stop without calling one of these two tools.
+
+### Output Schema
+The \`complete_task\` tool expects a \`result\` object matching this JSON Schema:
+\`\`\`json
+${JSON.stringify(outputSchema, null, 2)}
+\`\`\`
+
+### Completion Tools
+- **\`complete_task({ result: ... })\`** \u2014 Call when the task is done. The result is validated against the schema above. If validation fails you will get errors back \u2014 fix and retry.
+- **\`task_failed({ reason: "..." })\`** \u2014 Call only if the task truly cannot be completed.
+`;
+}
 function createSummaryPrompt(conversationHistory) {
   return `Please provide a concise summary of the following conversation history. Focus on:
 1. The main task or goal being worked on
@@ -4988,6 +5241,25 @@ ${this.summary}`
   }
 };
 
+// src/utils/webhook.ts
+async function sendWebhook(url, event) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-SparkECoder-Event": event.type
+      },
+      body: JSON.stringify(event),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+  } catch {
+  }
+}
+
 // src/agent/index.ts
 var approvalResolvers = /* @__PURE__ */ new Map();
 var Agent = class _Agent {
@@ -5207,6 +5479,145 @@ ${prompt}` });
       steps: result.steps
     };
   }
+  /**
+   * Run the agent in task mode — loops autonomously until the agent calls
+   * complete_task or task_failed (or hits maxIterations).
+   * All tools run without approval. Webhook events are fired throughout.
+   */
+  async runTask(options) {
+    const config = getConfig();
+    const maxIterations = options.taskConfig.maxIterations ?? 50;
+    const webhookUrl = options.taskConfig.webhookUrl;
+    const fireWebhook = (type, data) => {
+      if (!webhookUrl) return;
+      sendWebhook(webhookUrl, {
+        type,
+        taskId: this.session.id,
+        sessionId: this.session.id,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data
+      });
+    };
+    const completion = { signal: null };
+    const onComplete = (signal) => {
+      completion.signal = signal;
+    };
+    const taskTools = await createTools({
+      sessionId: this.session.id,
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      onBashProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "bash", data: progress }) : void 0,
+      onWriteFileProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "write_file", data: progress }) : void 0,
+      onSearchProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "explore_agent", data: progress }) : void 0,
+      taskTools: {
+        outputSchema: options.taskConfig.outputSchema,
+        onComplete
+      }
+    });
+    const baseSystemPrompt = await buildSystemPrompt({
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      sessionId: this.session.id,
+      discoveredSkills: config.discoveredSkills,
+      activeFiles: []
+    });
+    const taskAddendum = buildTaskPromptAddendum(options.taskConfig.outputSchema);
+    const systemPrompt = `${baseSystemPrompt}
+
+${taskAddendum}`;
+    fireWebhook("task.started", { prompt: options.prompt });
+    this.context.addUserMessage(options.prompt);
+    let iteration = 0;
+    while (iteration < maxIterations) {
+      iteration++;
+      if (options.abortSignal?.aborted) {
+        const cancelError = "Task was cancelled";
+        fireWebhook("task.failed", { status: "failed", error: cancelError, iterations: iteration });
+        return { status: "failed", error: cancelError, iterations: iteration };
+      }
+      const messages = await this.context.getMessages();
+      const useAnthropic = isAnthropicModel(this.session.model);
+      const result = await generateText3({
+        model: resolveModel(this.session.model),
+        system: systemPrompt,
+        messages,
+        tools: taskTools,
+        stopWhen: stepCountIs2(500),
+        abortSignal: options.abortSignal,
+        providerOptions: useAnthropic ? {
+          anthropic: {
+            thinking: { type: "enabled", budgetTokens: 1e4 }
+          }
+        } : void 0,
+        onStepFinish: (step) => {
+          options.onStepFinish?.(step);
+          fireWebhook("task.step_finished", { iteration, text: step.text });
+        }
+      });
+      const responseMessages = result.response.messages;
+      this.context.addResponseMessages(responseMessages);
+      if (result.text) {
+        options.onText?.(result.text);
+        fireWebhook("task.message", { iteration, text: result.text });
+      }
+      for (const step of result.steps) {
+        if (step.toolCalls) {
+          for (const tc of step.toolCalls) {
+            options.onToolCall?.({ toolCallId: tc.toolCallId, toolName: tc.toolName, input: tc.args });
+            fireWebhook("task.tool_call", { iteration, toolName: tc.toolName, toolCallId: tc.toolCallId, input: tc.args });
+          }
+        }
+        if (step.toolResults) {
+          for (const tr of step.toolResults) {
+            options.onToolResult?.({ toolCallId: tr.toolCallId, toolName: tr.toolName, output: tr.result });
+            fireWebhook("task.tool_result", { iteration, toolName: tr.toolName, toolCallId: tr.toolCallId, output: tr.result });
+          }
+        }
+      }
+      if (completion.signal) {
+        const sig = completion.signal;
+        const finalStatus = sig.status;
+        const eventType = finalStatus === "completed" ? "task.completed" : "task.failed";
+        fireWebhook(eventType, {
+          status: finalStatus,
+          result: sig.result,
+          error: sig.error,
+          iterations: iteration
+        });
+        const updatedTask2 = {
+          ...options.taskConfig,
+          status: finalStatus,
+          result: sig.result,
+          error: sig.error,
+          iterations: iteration
+        };
+        await sessionQueries.update(this.session.id, {
+          config: { ...this.session.config, task: updatedTask2 }
+        });
+        return {
+          status: finalStatus,
+          result: sig.result,
+          error: sig.error,
+          iterations: iteration
+        };
+      }
+      this.context.addUserMessage(
+        "Continue working on the task. When done, call `complete_task` with the result. If you cannot complete it, call `task_failed` with a reason."
+      );
+    }
+    const timeoutError = `Task did not complete within ${maxIterations} iterations`;
+    fireWebhook("task.failed", { status: "failed", error: timeoutError, iterations: iteration });
+    const updatedTask = {
+      ...options.taskConfig,
+      status: "failed",
+      error: timeoutError,
+      iterations: iteration
+    };
+    await sessionQueries.update(this.session.id, {
+      config: { ...this.session.config, task: updatedTask }
+    });
+    return { status: "failed", error: timeoutError, iterations: iteration };
+  }
   /**
    * Wrap tools to add approval checking
    */
@@ -5220,9 +5631,9 @@ ${prompt}` });
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool11({
+      wrappedTools[name] = tool12({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z12.object({}),
+        inputSchema: originalTool.inputSchema || z13.object({}),
         execute: async (input, toolOptions) => {
           const toolCallId = toolOptions.toolCallId || nanoid3();
           const execution = toolExecutionQueries.create({
@@ -5333,6 +5744,7 @@ ${prompt}` });
 export {
   Agent,
   ContextManager,
-  buildSystemPrompt
+  buildSystemPrompt,
+  buildTaskPromptAddendum
 };
 //# sourceMappingURL=index.js.map