@capekai/core 1.0.1 → 1.0.3

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@capekai/core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Bun-native composable agent runtime and framework for Capek.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/capek-dev/prokop.git",
+    "url": "git+https://github.com/capek-dev/capek.git",
     "directory": "packages/capek"
   },
   "type": "module",
@@ -77,7 +77,7 @@
   "dependencies": {
     "@ai-sdk/deepseek": "^2.0.35",
     "@ai-sdk/openai": "^3.0.84",
-    "@capekai/tool": "^1.0.0",
+    "@capekai/tool": "^1.0.2",
     "@capekai/types": "^1.0.1",
     "@openrouter/ai-sdk-provider": "^2.3.3",
     "@zip.js/zip.js": "^2.7.60",

package/src/plugins/subagent-domain.ts

@@ -276,7 +276,7 @@ export function subagentDomainPlugin(id: string): CapekPlugin<unknown> {
           name: service.tools[0].name,
           description: service.tools[0].description,
           inputSchema: service.tools[0].inputSchema,
-          timeout: 300000,
+          timeout: null,
           [DOMAIN_TOOL_PAYLOAD_FIELD]: service.tools[0],
         } as KernelToolDefinition,
         requiredCapabilities: [capekSubagentDomainKey],

package/src/subagent/task-tool.ts

@@ -133,7 +133,7 @@ When NOT to use it:
 Pattern for aggregation (map-reduce): define one schema, spawn N agents each with that outputSchema, then in your next turn merge the returned JSON objects. This keeps your context clean because you can reason about the data instead of re-parsing prose from each agent.
 
 Note: Subagent depth is limited to 2 levels. You cannot spawn further subagents at the maximum depth.`,
-    timeout: 300000,
+    timeout: null,
     inputSchema: {
       type: 'object',
       properties: {

package/src/tools/executor.ts

@@ -34,7 +34,9 @@ export interface ExecuteToolOptions {
   workspaceId?: string;
   toolCallId?: string;
   abortSignal?: AbortSignal;
-  timeout?: number;
+  /** Milliseconds deadline. Pass `null` (or declare it on the tool
+   * definition) to run without a deadline until interrupted. */
+  timeout?: number | null;
   createLlmApi?: (defaultModel?: string) => LlmApi;
   createAskApi?: (toolCallId: string) => AskApi;
   broadcastFn?: (event: { type: string; [key: string]: unknown }) => void;
@@ -172,7 +174,9 @@ export async function executeTool(options: ExecuteToolOptions): Promise<ToolResu
     workspace,
     sessionId,
     abortSignal,
-    timeout = tool.definition.timeout ?? 30000,
+    // Definition null is authoritative "no deadline"; only an absent
+    // definition falls back to the 30s default.
+    timeout = tool.definition.timeout === undefined ? 30000 : tool.definition.timeout,
     createLlmApi,
     createAskApi,
   } = options;
@@ -201,6 +205,7 @@ export async function executeTool(options: ExecuteToolOptions): Promise<ToolResu
     logger: createLogger(tool.definition.name, sessionId),
     fetch: globalThis.fetch.bind(globalThis),
     resolvePath: workspace.resolvePath,
+    resolvePathFrom: workspace.resolvePathFrom,
     isWithinWorkspace: workspace.isWithinWorkspace,
     isSensitivePath: workspace.isSensitivePath,
     isBlockedPath: workspace.isBlockedPath,
@@ -211,12 +216,16 @@ export async function executeTool(options: ExecuteToolOptions): Promise<ToolResu
   const executePromise = tool.execute(args, ctx);
 
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    timeoutId = setTimeout(() => {
-      toolAbortController.abort(new Error(`Tool execution timed out after ${timeout}ms`));
-      reject(new Error(`Tool execution timed out after ${timeout}ms`));
-    }, timeout);
-  });
+  // `timeout === null` is the tool's explicit "no deadline": the executor
+  // arms no timer and the tool runs until it settles or is interrupted.
+  const timeoutPromise = timeout === null
+    ? null
+    : new Promise<never>((_, reject) => {
+        timeoutId = setTimeout(() => {
+          toolAbortController.abort(new Error(`Tool execution timed out after ${timeout}ms`));
+          reject(new Error(`Tool execution timed out after ${timeout}ms`));
+        }, timeout);
+      });
 
   // Abort must settle the race even when the tool ignores its abort signal
   // (for example a tool blocked on ctx.ask()). Promise.race keeps handlers
@@ -232,10 +241,12 @@ export async function executeTool(options: ExecuteToolOptions): Promise<ToolResu
       })
     : null;
 
+  const racers = timeoutPromise
+    ? (abortPromise ? [executePromise, timeoutPromise, abortPromise] : [executePromise, timeoutPromise])
+    : (abortPromise ? [executePromise, abortPromise] : [executePromise]);
+
   try {
-    const result = await Promise.race(
-      abortPromise ? [executePromise, timeoutPromise, abortPromise] : [executePromise, timeoutPromise],
-    );
+    const result = await Promise.race(racers);
     return result;
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : String(err);

package/src/workspace/contracts.ts

@@ -41,6 +41,7 @@ export interface WorkspaceCapability {
   allowedRoots: string[];
   tempDir: string;
   resolvePath(path: string): string;
+  resolvePathFrom(path: string, basePath: string): string;
   isWithinWorkspace(path: string): boolean;
   isSensitivePath(path: string): boolean;
   isBlockedPath(path: string): boolean;

package/src/workspace/policy.ts

@@ -78,14 +78,18 @@ export function createWorkspaceCapabilityWithOptions(
   const additionalRoots = (host.additionalRoots ?? []).map((path) => resolve(path));
   const allowedRoots = (host.allowedRoots ?? []).map((path) => resolve(path));
 
-  function resolvePath(path: string): string {
+  function resolvePathFrom(path: string, basePath: string): string {
     if (path === '~' || path.startsWith('~/')) {
       return join(options.homeDir, path.slice(1));
     }
     if (isAbsolute(path)) {
       return resolve(path);
     }
-    return resolve(effectiveRoot, path);
+    return resolve(basePath, path);
+  }
+
+  function resolvePath(path: string): string {
+    return resolvePathFrom(path, effectiveRoot);
   }
 
   return {
@@ -94,6 +98,7 @@ export function createWorkspaceCapabilityWithOptions(
     allowedRoots,
     tempDir: host.tempDir,
     resolvePath,
+    resolvePathFrom,
     isWithinWorkspace(path: string): boolean {
       const resolvedPath = resolvePath(path);
       return [effectiveRoot, ...additionalRoots]