Skip to content

armgit / Orkas

Public Imported from GitHub
0

Orkas is an open-source (MIT), local-first AI team for your desktop: a Commander turns your goal into to-dos and coordinates 16 built-in specialist agents plus Claude Code, Codex, OpenCode, OpenClaw and Hermes, with projects, scheduled automations and connectors. Free app for macOS & Windows; built-in models or your own keys.

Fix agent tool timeout regressions

wyte206b042abcb
diff --git a/bin/run-skill.cjs b/bin/run-skill.cjs
index 59b8691d..8904e31f 100755
--- a/bin/run-skill.cjs
+++ b/bin/run-skill.cjs
@@ -357,6 +357,9 @@ function findGitBash() {
if (existingFile(p)) return p;
}
+ const pathCandidate = findOnPath(['bash.exe', 'bash']);
+ if (pathCandidate) return pathCandidate;
+
const roots = [
process.env.ProgramFiles,
process.env['ProgramFiles(x86)'],
diff --git a/src/core-agent/src/agent/runner.ts b/src/core-agent/src/agent/runner.ts
index 125976b5..13b92f73 100644
--- a/src/core-agent/src/agent/runner.ts
+++ b/src/core-agent/src/agent/runner.ts
@@ -751,7 +751,7 @@ export class AgentRunner {
const provider = resolved.provider;
const modelId = resolved.modelId;
const toolDefs = [...this.tools.values()].map(toToolDefinition);
- const toolCtx: ToolContext = { state: sandboxEnv ? { sandboxEnv } : {} };
+ const toolState: ToolContext["state"] = sandboxEnv ? { sandboxEnv } : {};
// Single-turn reflection: send prompt, execute any tool calls, done.
log.info(`Reflection starting: model=${modelId}`);
@@ -793,7 +793,13 @@ export class AgentRunner {
}
try {
log.info(`Reflection tool: ${call.name}(${JSON.stringify(call.input).slice(0, 200)})`);
- const toolResult = await tool.execute(call.input, toolCtx);
+ const toolResult = await executeReflectionTool(
+ tool,
+ call.input,
+ toolState,
+ signal,
+ this.config.agent.toolIdleTimeoutMs,
+ );
reflectSession.addToolResult(call.id, toolResult.content, toolResult.images, toolResult.isError);
if (toolResult.isError) {
log.warn(`Reflection tool ${call.name} returned error: ${toolResult.content.slice(0, 200)}`);
@@ -860,6 +866,68 @@ export class AgentRunner {
}
}
+async function executeReflectionTool(
+ tool: AgentTool,
+ input: Record<string, unknown>,
+ state: ToolContext["state"],
+ signal: AbortSignal | undefined,
+ toolIdleTimeoutMs: number,
+): Promise<ToolResult> {
+ const abortedToolMessage = "Tool execution aborted: Run aborted";
+ const stalledToolMessage =
+ `Tool execution stalled after ${toolIdleTimeoutMs}ms without substantive progress`;
+
+ if (signal?.aborted) {
+ return { content: abortedToolMessage, isError: true };
+ }
+
+ const toolAbort = createChildAbortController(signal);
+ const toolIdle = createToolIdleWatchdog(toolIdleTimeoutMs);
+ const toolCtx: ToolContext = {
+ signal: toolAbort.signal,
+ state,
+ emitProgress: (progress) => {
+ const message = String(progress?.message || "").trim();
+ if (!message) return;
+ const idleDelayMs = toolIdleDelayForProgress(progress, toolIdleTimeoutMs);
+ if (idleDelayMs != null) toolIdle.reset(idleDelayMs);
+ },
+ };
+ type ToolCompletion =
+ | { ok: true; result: ToolResult }
+ | { ok: false; err: unknown };
+ const toolPromise: Promise<ToolCompletion> = Promise.resolve()
+ .then(() => tool.execute(input, toolCtx))
+ .then(
+ (result) => ({ ok: true as const, result }),
+ (err) => ({ ok: false as const, err }),
+ );
+ const abortWait = waitForAbort(signal);
+
+ try {
+ const waits: Array<Promise<ToolCompletion | "abort" | "tool_idle">> = [
+ toolPromise,
+ toolIdle.promise,
+ ];
+ if (abortWait.promise) waits.push(abortWait.promise);
+ const raced = await Promise.race(waits);
+ if (raced === "tool_idle") {
+ toolAbort.abort();
+ return { content: stalledToolMessage, isError: true };
+ }
+ if (raced === "abort") {
+ toolAbort.abort();
+ return { content: abortedToolMessage, isError: true };
+ }
+ if (raced.ok === false) throw raced.err;
+ return raced.result;
+ } finally {
+ abortWait.cleanup();
+ toolIdle.cancel();
+ toolAbort.cleanup();
+ }
+}
+
function sleep(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms));
}
diff --git a/src/core-agent/src/tools/builtin.ts b/src/core-agent/src/tools/builtin.ts
index f6d1f4b0..979e0bed 100644
--- a/src/core-agent/src/tools/builtin.ts
+++ b/src/core-agent/src/tools/builtin.ts
@@ -70,12 +70,15 @@ export const DEFAULT_BASH_TIMEOUT_MS = 30 * 60_000;
export const BASH_PROGRESS_INTERVAL_MS = 60_000;
const LEGACY_DEFAULT_BASH_TIMEOUTS_MS = new Set([30_000, 300_000]);
-export function normalizeBashTimeoutMs(value: unknown): number {
+export function normalizeBashTimeoutMs(
+ value: unknown,
+ opts: { legacyDefault?: boolean } = {},
+): number {
if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
return DEFAULT_BASH_TIMEOUT_MS;
}
const timeoutMs = Math.round(value);
- return LEGACY_DEFAULT_BASH_TIMEOUTS_MS.has(timeoutMs)
+ return opts.legacyDefault && LEGACY_DEFAULT_BASH_TIMEOUTS_MS.has(timeoutMs)
? DEFAULT_BASH_TIMEOUT_MS
: timeoutMs;
}
diff --git a/src/core-agent/test/agent-runner.test.ts b/src/core-agent/test/agent-runner.test.ts
index 542fec61..4a7f6918 100644
--- a/src/core-agent/test/agent-runner.test.ts
+++ b/src/core-agent/test/agent-runner.test.ts
@@ -642,6 +642,79 @@ describe("AgentRunner", () => {
expect(done.result?.meta?.permanentToolErrors).toBeUndefined();
});
+ it("runReflection converts a wedged tool into an error result and continues", async () => {
+ const seenMessages: Message[][] = [];
+ const mockProvider: LLMProvider = {
+ id: "mock",
+ name: "Mock Provider",
+ async complete(params) {
+ seenMessages.push(params.messages);
+ if (seenMessages.length === 1) {
+ return {
+ content: [
+ { type: "tool_use", id: "call_1", name: "wedged_tool", input: {} },
+ ],
+ stopReason: "tool_use",
+ usage: { inputTokens: 5, outputTokens: 3, totalTokens: 8 },
+ model: "mock-model",
+ };
+ }
+ return {
+ content: [{ type: "text", text: "reflection continued" }],
+ stopReason: "end_turn",
+ usage: { inputTokens: 7, outputTokens: 5, totalTokens: 12 },
+ model: "mock-model",
+ };
+ },
+ async *stream() {
+ throw new Error("stream not used");
+ },
+ async validateAuth() {
+ return true;
+ },
+ };
+
+ const registry = new ProviderRegistry();
+ registry.registerFactory("mock", () => mockProvider);
+ let capturedSignal: AbortSignal | undefined;
+ const wedgedTool = defineTool({
+ name: "wedged_tool",
+ description: "Never resolves",
+ inputSchema: { type: "object", properties: {} },
+ async execute(_input, ctx) {
+ capturedSignal = ctx.signal;
+ return new Promise<never>(() => undefined);
+ },
+ });
+ const config = createConfig({
+ agent: {
+ defaultProvider: "mock",
+ defaultModel: "mock-model",
+ toolIdleTimeoutMs: 30,
+ },
+ });
+
+ const runner = new AgentRunner({ config, providers: registry, tools: [wedgedTool] });
+ const result = await Promise.race([
+ runner.runReflection("reflect"),
+ new Promise<string>((_, reject) => setTimeout(() => reject(new Error("timed out")), 1000)),
+ ]);
+
+ expect(result).toBe("reflection continued");
+ expect(capturedSignal?.aborted).toBe(true);
+ expect(seenMessages).toHaveLength(2);
+ const toolResults = seenMessages[1].flatMap((msg) =>
+ msg.content.filter((content) => content.type === "tool_result"),
+ );
+ expect(toolResults).toHaveLength(1);
+ expect(toolResults[0]).toMatchObject({
+ type: "tool_result",
+ toolUseId: "call_1",
+ content: "Tool execution stalled after 30ms without substantive progress",
+ isError: true,
+ });
+ });
+
it("runStream forwards tool input deltas before tool execution", async () => {
const mockProvider = createMockProvider([
{
diff --git a/src/core-agent/test/tools.test.ts b/src/core-agent/test/tools.test.ts
index 93f4f77c..ba8f8161 100644
--- a/src/core-agent/test/tools.test.ts
+++ b/src/core-agent/test/tools.test.ts
@@ -118,10 +118,13 @@ describe("Tools", () => {
});
describe("bash tool", () => {
- it("normalizes legacy default timeout values to the long bash timeout", () => {
+ it("uses the long default only for missing or legacy-synthetic timeout values", () => {
expect(normalizeBashTimeoutMs(undefined)).toBe(DEFAULT_BASH_TIMEOUT_MS);
- expect(normalizeBashTimeoutMs(30_000)).toBe(DEFAULT_BASH_TIMEOUT_MS);
- expect(normalizeBashTimeoutMs(300_000)).toBe(DEFAULT_BASH_TIMEOUT_MS);
+ expect(normalizeBashTimeoutMs(-1)).toBe(DEFAULT_BASH_TIMEOUT_MS);
+ expect(normalizeBashTimeoutMs(30_000)).toBe(30_000);
+ expect(normalizeBashTimeoutMs(300_000)).toBe(300_000);
+ expect(normalizeBashTimeoutMs(30_000, { legacyDefault: true })).toBe(DEFAULT_BASH_TIMEOUT_MS);
+ expect(normalizeBashTimeoutMs(300_000, { legacyDefault: true })).toBe(DEFAULT_BASH_TIMEOUT_MS);
expect(normalizeBashTimeoutMs(5_000)).toBe(5_000);
});
diff --git a/test/main/util/run-skill.test.ts b/test/main/util/run-skill.test.ts
index 8818aafe..46f2e671 100644
--- a/test/main/util/run-skill.test.ts
+++ b/test/main/util/run-skill.test.ts
@@ -50,6 +50,14 @@ function runSkill(skillRef: string, scriptBase: string, args: string[] = [], ext
}
describe('run-skill.cjs', () => {
+ it('checks PATH when locating Git Bash for Windows shell scripts', () => {
+ const source = fs.readFileSync(path.join(process.cwd(), 'bin', 'run-skill.cjs'), 'utf8');
+ const body = source.match(/function findGitBash\(\) \{[\s\S]*?\n\}/)?.[0] ?? '';
+
+ expect(body).toContain("findOnPath(['bash.exe', 'bash'])");
+ expect(body.indexOf('findOnPath')).toBeLessThan(body.indexOf('const roots'));
+ });
+
it('resolves marketplace scripts by SKILL.md display name when dir id differs', () => {
writeMarketplaceSkill('252af214f470', 'social-fetch', 'fetch');