sparkecoder 0.1.60 → 0.1.61

package/dist/tools/index.d.ts

@@ -1,7 +1,40 @@
 import * as ai from 'ai';
 import { ToolSet } from 'ai';
-import { B as BashToolProgress, W as WriteFileProgress, S as SearchToolProgress } from '../search-BETuS1vh.js';
-export { b as BashToolOptions, d as SearchToolOptions, e as WriteFileToolOptions, c as createBashTool, f as createSearchTool, a as createWriteFileTool } from '../search-BETuS1vh.js';
+import { B as BashToolProgress, W as WriteFileProgress, S as SearchToolProgress } from '../search-C_IFImt1.js';
+export { b as BashToolOptions, d as SearchToolOptions, e as WriteFileToolOptions, c as createBashTool, f as createSearchTool, a as createWriteFileTool } from '../search-C_IFImt1.js';
+
+interface TaskCompletionSignal {
+    status: 'completed' | 'failed';
+    result?: unknown;
+    error?: string;
+}
+interface CreateTaskToolsOptions {
+    outputSchema: Record<string, unknown>;
+    onComplete: (signal: TaskCompletionSignal) => void;
+}
+declare function createCompleteTaskTool(options: CreateTaskToolsOptions): ai.Tool<{
+    result: Record<string, unknown>;
+}, {
+    status: string;
+    message: string;
+    errors: {
+        path: string;
+        message: string | undefined;
+        params: Record<string, any>;
+    }[] | undefined;
+    expectedSchema: Record<string, unknown>;
+} | {
+    status: string;
+    message: string;
+    errors?: undefined;
+    expectedSchema?: undefined;
+}>;
+declare function createTaskFailedTool(options: Pick<CreateTaskToolsOptions, 'onComplete'>): ai.Tool<{
+    reason: string;
+}, {
+    status: string;
+    message: string;
+}>;
 
 interface ReadFileToolOptions {
     workingDirectory: string;
@@ -327,6 +360,8 @@ interface CreateToolsOptions {
     enableLSP?: boolean;
     /** Enable semantic search if configured (default: true) */
     enableSemanticSearch?: boolean;
+    /** Task mode: include complete_task and task_failed tools */
+    taskTools?: CreateTaskToolsOptions;
 }
 /**
  * Create all tools for an agent session
@@ -334,4 +369,4 @@ interface CreateToolsOptions {
  */
 declare function createTools(options: CreateToolsOptions): Promise<ToolSet>;
 
-export { BashToolProgress, type CodeGraphToolOptions, type CreateToolsOptions, type LinterToolOptions, type LoadSkillToolOptions, type ReadFileToolOptions, SearchToolProgress, type SemanticSearchResult, type SemanticSearchToolOptions, type TodoToolOptions, WriteFileProgress, createCodeGraphTool, createLinterTool, createLoadSkillTool, createReadFileTool, createSemanticSearchTool, createTodoTool, createTools };
+export { BashToolProgress, type CodeGraphToolOptions, type CreateTaskToolsOptions, type CreateToolsOptions, type LinterToolOptions, type LoadSkillToolOptions, type ReadFileToolOptions, SearchToolProgress, type SemanticSearchResult, type SemanticSearchToolOptions, type TaskCompletionSignal, type TodoToolOptions, WriteFileProgress, createCodeGraphTool, createCompleteTaskTool, createLinterTool, createLoadSkillTool, createReadFileTool, createSemanticSearchTool, createTaskFailedTool, createTodoTool, createTools };

package/dist/tools/index.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 
 // 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";
@@ -29,11 +29,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)
@@ -2911,7 +2922,165 @@ import { nanoid as nanoid2 } from "nanoid";
 
 // 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();
 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 = {
@@ -4081,6 +4250,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) {
@@ -4132,16 +4354,22 @@ async function createTools(options) {
     } catch {
     }
   }
+  if (options.taskTools) {
+    tools.complete_task = createCompleteTaskTool(options.taskTools);
+    tools.task_failed = createTaskFailedTool(options.taskTools);
+  }
   return tools;
 }
 export {
   createBashTool,
   createCodeGraphTool,
+  createCompleteTaskTool,
   createLinterTool,
   createLoadSkillTool,
   createReadFileTool,
   createSearchTool,
   createSemanticSearchTool,
+  createTaskFailedTool,
   createTodoTool,
   createTools,
   createWriteFileTool