sparkecoder 0.1.60 → 0.1.61

package/dist/server/index.js

@@ -367,7 +367,7 @@ var init_db = __esm({
 
 // src/config/types.ts
 import { z } from "zod";
-var ToolApprovalConfigSchema, SkillMetadataSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
+var ToolApprovalConfigSchema, SkillMetadataSchema, TaskConfigSchema, SessionConfigSchema, VectorGatewayConfigSchema, RemoteServerConfigSchema, SparkcoderConfigSchema;
 var init_types = __esm({
   "src/config/types.ts"() {
     "use strict";
@@ -386,11 +386,22 @@ var init_types = __esm({
       // 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)
+      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)
@@ -698,6 +709,9 @@ function getConfig() {
 }
 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];
   }
@@ -1605,7 +1619,7 @@ var init_semantic_search = __esm({
 
 // src/server/index.ts
 import "dotenv/config";
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
@@ -1619,7 +1633,7 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 init_db();
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 import { existsSync as existsSync13, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readdirSync, statSync as statSync2, unlinkSync } from "fs";
 import { readdir as readdir5 } from "fs/promises";
 import { join as join5, basename as basename4, extname as extname7, relative as relative9 } from "path";
@@ -1629,18 +1643,176 @@ import { nanoid as nanoid4 } from "nanoid";
 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 = {
@@ -1652,7 +1824,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
@@ -4962,6 +5134,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) {
@@ -5013,6 +5238,10 @@ async function createTools(options) {
     } catch {
     }
   }
+  if (options.taskTools) {
+    tools.complete_task = createCompleteTaskTool(options.taskTools);
+    tools.task_failed = createTaskFailedTool(options.taskTools);
+  }
   return tools;
 }
 
@@ -5330,6 +5559,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
@@ -5591,6 +5844,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 {
@@ -5810,6 +6082,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
    */
@@ -5823,9 +6234,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({
@@ -5966,18 +6377,18 @@ function cleanupPendingInputs() {
     }
   }
 }
-var createSessionSchema = z13.object({
-  name: z13.string().optional(),
-  workingDirectory: z13.string().optional(),
-  model: z13.string().optional(),
-  toolApprovals: z13.record(z13.string(), z13.boolean()).optional()
+var createSessionSchema = z14.object({
+  name: z14.string().optional(),
+  workingDirectory: z14.string().optional(),
+  model: z14.string().optional(),
+  toolApprovals: z14.record(z14.string(), z14.boolean()).optional()
 });
-var paginationQuerySchema = z13.object({
-  limit: z13.string().optional(),
-  offset: z13.string().optional()
+var paginationQuerySchema = z14.object({
+  limit: z14.string().optional(),
+  offset: z14.string().optional()
 });
-var messagesQuerySchema = z13.object({
-  limit: z13.string().optional()
+var messagesQuerySchema = z14.object({
+  limit: z14.string().optional()
 });
 sessions.get(
   "/",
@@ -6116,10 +6527,10 @@ sessions.get("/:id/tools", async (c) => {
     count: executions.length
   });
 });
-var updateSessionSchema = z13.object({
-  model: z13.string().optional(),
-  name: z13.string().optional(),
-  toolApprovals: z13.record(z13.string(), z13.boolean()).optional()
+var updateSessionSchema = z14.object({
+  model: z14.string().optional(),
+  name: z14.string().optional(),
+  toolApprovals: z14.record(z14.string(), z14.boolean()).optional()
 });
 sessions.patch(
   "/:id",
@@ -6189,8 +6600,8 @@ sessions.post("/:id/clear", async (c) => {
   await agent.clearContext();
   return c.json({ success: true, sessionId: id });
 });
-var pendingInputSchema = z13.object({
-  text: z13.string()
+var pendingInputSchema = z14.object({
+  text: z14.string()
 });
 sessions.post(
   "/:id/pending-input",
@@ -6221,13 +6632,13 @@ sessions.get("/:id/pending-input", async (c) => {
     createdAt: pending.createdAt.toISOString()
   });
 });
-var devtoolsContextSchema = z13.object({
-  url: z13.string(),
-  path: z13.string(),
-  pageName: z13.string().optional(),
-  screenWidth: z13.number().optional(),
-  screenHeight: z13.number().optional(),
-  devicePixelRatio: z13.number().optional()
+var devtoolsContextSchema = z14.object({
+  url: z14.string(),
+  path: z14.string(),
+  pageName: z14.string().optional(),
+  screenWidth: z14.number().optional(),
+  screenHeight: z14.number().optional(),
+  devicePixelRatio: z14.number().optional()
 });
 sessions.post(
   "/:id/devtools-context",
@@ -6518,10 +6929,10 @@ sessions.delete("/:id/attachments/:attachmentId", async (c) => {
   unlinkSync(filePath);
   return c.json({ success: true, id: attachmentId });
 });
-var filesQuerySchema = z13.object({
-  query: z13.string().optional(),
+var filesQuerySchema = z14.object({
+  query: z14.string().optional(),
   // Filter query (e.g., "src/com" to match "src/components")
-  limit: z13.string().optional()
+  limit: z14.string().optional()
   // Max results (default 50)
 });
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -6699,7 +7110,7 @@ sessions.get(
 init_db();
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join6 } from "path";
 init_config();
@@ -6864,30 +7275,30 @@ function enrichPromptWithDevtoolsContext(sessionId, prompt) {
 ${prompt}`;
 }
 var agents = new Hono2();
-var attachmentSchema = z14.object({
-  type: z14.enum(["image", "file"]),
-  data: z14.string(),
+var attachmentSchema = z15.object({
+  type: z15.enum(["image", "file"]),
+  data: z15.string(),
   // base64 data URL or raw base64
-  mediaType: z14.string().optional(),
-  filename: z14.string().optional()
+  mediaType: z15.string().optional(),
+  filename: z15.string().optional()
 });
-var runPromptSchema = z14.object({
-  prompt: z14.string(),
+var runPromptSchema = z15.object({
+  prompt: z15.string(),
   // Can be empty if attachments are provided
-  attachments: z14.array(attachmentSchema).optional()
+  attachments: z15.array(attachmentSchema).optional()
 }).refine(
   (data) => data.prompt.trim().length > 0 || data.attachments && data.attachments.length > 0,
   { message: "Either prompt or attachments must be provided" }
 );
-var quickStartSchema = z14.object({
-  prompt: z14.string().min(1),
-  name: z14.string().optional(),
-  workingDirectory: z14.string().optional(),
-  model: z14.string().optional(),
-  toolApprovals: z14.record(z14.string(), z14.boolean()).optional()
+var quickStartSchema = z15.object({
+  prompt: z15.string().min(1),
+  name: z15.string().optional(),
+  workingDirectory: z15.string().optional(),
+  model: z15.string().optional(),
+  toolApprovals: z15.record(z15.string(), z15.boolean()).optional()
 });
-var rejectSchema = z14.object({
-  reason: z14.string().optional()
+var rejectSchema = z15.object({
+  reason: z15.string().optional()
 }).optional();
 var streamAbortControllers = /* @__PURE__ */ new Map();
 function getAttachmentsDirectory(sessionId) {
@@ -7317,7 +7728,7 @@ agents.get("/:id/watch", async (c) => {
       "Cache-Control": "no-cache",
       "Connection": "keep-alive",
       "x-vercel-ai-ui-message-stream": "v1",
-      "x-stream-id": streamId
+      "x-stream-id": streamId ?? ""
     }
   });
 });
@@ -7675,7 +8086,7 @@ agents.post(
 init_config();
 import { Hono as Hono3 } from "hono";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 import { readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname as dirname6, join as join7 } from "path";
@@ -7785,9 +8196,9 @@ health.get("/api-keys", async (c) => {
     supportedProviders: SUPPORTED_PROVIDERS
   });
 });
-var setApiKeySchema = z15.object({
-  provider: z15.string(),
-  apiKey: z15.string().min(1)
+var setApiKeySchema = z16.object({
+  provider: z16.string(),
+  apiKey: z16.string().min(1)
 });
 health.post(
   "/api-keys",
@@ -7826,13 +8237,13 @@ health.delete("/api-keys/:provider", async (c) => {
 // src/server/routes/terminals.ts
 import { Hono as Hono4 } from "hono";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 init_db();
 var terminals = new Hono4();
-var spawnSchema = z16.object({
-  command: z16.string(),
-  cwd: z16.string().optional(),
-  name: z16.string().optional()
+var spawnSchema = z17.object({
+  command: z17.string(),
+  cwd: z17.string().optional(),
+  name: z17.string().optional()
 });
 terminals.post(
   "/:sessionId/terminals",
@@ -7913,8 +8324,8 @@ terminals.get("/:sessionId/terminals/:terminalId", async (c) => {
     // We don't track exit codes in tmux mode
   });
 });
-var logsQuerySchema = z16.object({
-  tail: z16.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
+var logsQuerySchema = z17.object({
+  tail: z17.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
 });
 terminals.get(
   "/:sessionId/terminals/:terminalId/logs",
@@ -7938,8 +8349,8 @@ terminals.get(
     });
   }
 );
-var killSchema = z16.object({
-  signal: z16.enum(["SIGTERM", "SIGKILL"]).optional()
+var killSchema = z17.object({
+  signal: z17.enum(["SIGTERM", "SIGKILL"]).optional()
 });
 terminals.post(
   "/:sessionId/terminals/:terminalId/kill",
@@ -7953,8 +8364,8 @@ terminals.post(
     return c.json({ success: true, message: "Terminal killed" });
   }
 );
-var writeSchema = z16.object({
-  input: z16.string()
+var writeSchema = z17.object({
+  input: z17.string()
 });
 terminals.post(
   "/:sessionId/terminals/:terminalId/write",
@@ -8135,6 +8546,131 @@ data: ${JSON.stringify({ status: "stopped" })}
   );
 });
 
+// src/server/routes/tasks.ts
+init_db();
+import { Hono as Hono5 } from "hono";
+import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { z as z18 } from "zod";
+init_config();
+var tasks = new Hono5();
+var taskAbortControllers = /* @__PURE__ */ new Map();
+var createTaskSchema = z18.object({
+  prompt: z18.string().min(1),
+  outputSchema: z18.record(z18.string(), z18.unknown()),
+  webhookUrl: z18.string().url().optional(),
+  model: z18.string().optional(),
+  workingDirectory: z18.string().optional(),
+  name: z18.string().optional(),
+  maxIterations: z18.number().int().min(1).max(500).optional()
+});
+tasks.post(
+  "/",
+  zValidator5("json", createTaskSchema),
+  async (c) => {
+    const body = c.req.valid("json");
+    const config = getConfig();
+    const taskConfig = {
+      enabled: true,
+      outputSchema: body.outputSchema,
+      webhookUrl: body.webhookUrl,
+      maxIterations: body.maxIterations ?? 50,
+      status: "running"
+    };
+    const agent = await Agent.create({
+      name: body.name || "Task",
+      workingDirectory: body.workingDirectory || config.resolvedWorkingDirectory,
+      model: body.model || config.defaultModel,
+      sessionConfig: {
+        toolApprovals: { bash: false, write_file: false, read_file: false },
+        task: taskConfig
+      }
+    });
+    const taskId = agent.sessionId;
+    const abortController = new AbortController();
+    taskAbortControllers.set(taskId, abortController);
+    (async () => {
+      try {
+        await agent.runTask({
+          prompt: body.prompt,
+          taskConfig,
+          abortSignal: abortController.signal
+        });
+      } catch (err) {
+        if (err.name === "AbortError" || abortController.signal.aborted) {
+          console.log(`[TASK] Task ${taskId} was cancelled`);
+        } else {
+          console.error(`[TASK] Error in task ${taskId}:`, err.message);
+          const failedTask = {
+            ...taskConfig,
+            status: "failed",
+            error: err.message || "Unknown error"
+          };
+          await sessionQueries.update(taskId, {
+            config: {
+              toolApprovals: { bash: false, write_file: false, read_file: false },
+              task: failedTask
+            }
+          });
+        }
+      } finally {
+        taskAbortControllers.delete(taskId);
+      }
+    })();
+    return c.json({ taskId, status: "running" }, 201);
+  }
+);
+tasks.get("/:id", async (c) => {
+  const id = c.req.param("id");
+  const session = await sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Task not found" }, 404);
+  }
+  const task = session.config?.task;
+  if (!task?.enabled) {
+    return c.json({ error: "Session is not a task" }, 400);
+  }
+  return c.json({
+    taskId: id,
+    status: task.status,
+    result: task.result,
+    error: task.error,
+    iterations: task.iterations,
+    model: session.model,
+    name: session.name,
+    createdAt: session.createdAt.toISOString(),
+    updatedAt: session.updatedAt.toISOString()
+  });
+});
+tasks.post("/:id/cancel", async (c) => {
+  const id = c.req.param("id");
+  const session = await sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Task not found" }, 404);
+  }
+  const task = session.config?.task;
+  if (!task?.enabled) {
+    return c.json({ error: "Session is not a task" }, 400);
+  }
+  if (task.status !== "running") {
+    return c.json({ error: `Task is already ${task.status}` }, 400);
+  }
+  const abortController = taskAbortControllers.get(id);
+  if (abortController) {
+    abortController.abort();
+    taskAbortControllers.delete(id);
+  }
+  const cancelledTask = {
+    ...task,
+    status: "failed",
+    error: "Task cancelled by user"
+  };
+  await sessionQueries.update(id, {
+    config: { ...session.config, task: cancelledTask }
+  });
+  return c.json({ taskId: id, status: "failed", error: "Task cancelled by user" });
+});
+var tasks_default = tasks;
+
 // src/server/index.ts
 init_config();
 init_db();
@@ -8471,7 +9007,7 @@ function stopWebUI() {
   }
 }
 async function createApp(options = {}) {
-  const app = new Hono5();
+  const app = new Hono6();
   app.use("*", cors({
     origin: "*",
     // Allow all origins
@@ -8489,6 +9025,7 @@ async function createApp(options = {}) {
   app.route("/agents", agents);
   app.route("/sessions", terminals);
   app.route("/terminals", terminals);
+  app.route("/tasks", tasks_default);
   app.get("/openapi.json", async (c) => {
     return c.json(generateOpenAPISpec());
   });