@zhijiewang/openharness 2.17.0 → 2.19.0

package/dist/providers/ollama.js

@@ -10,6 +10,45 @@ export class OllamaProvider {
         this.baseUrl = (config.baseUrl ?? "http://localhost:11434").replace(/\/$/, "");
         this.defaultModel = config.defaultModel ?? "llama3.1";
     }
+    /**
+     * Estimate the prompt size and pick a `num_ctx` for Ollama. Without this
+     * Ollama defaults to a 2048-token context window — anything bigger gets
+     * silently truncated server-side. OH's typical system prompt + tool list
+     * already pushes ~4 K, so multi-turn chats lose prior turns and the model
+     * appears to "forget" what was just said. See issue #61.
+     *
+     * Strategy: rough char/4 token estimate, +1 K headroom for the response,
+     * then round up to the next power of 2 ≥ 8192. Capped at 32 K to keep KV
+     * cache bounded; users with bigger models can override via
+     * `OLLAMA_NUM_CTX`.
+     */
+    computeNumCtx(messages, systemPrompt, tools) {
+        const override = process.env.OLLAMA_NUM_CTX;
+        if (override) {
+            const parsed = Number(override);
+            if (Number.isFinite(parsed) && parsed > 0)
+                return Math.floor(parsed);
+        }
+        const estimate = (s) => Math.ceil(s.length / 4);
+        let total = systemPrompt ? estimate(systemPrompt) : 0;
+        for (const m of messages) {
+            total += estimate(m.content);
+            if (m.toolCalls)
+                for (const tc of m.toolCalls)
+                    total += estimate(JSON.stringify(tc.arguments));
+            if (m.toolResults)
+                for (const tr of m.toolResults)
+                    total += estimate(tr.output);
+        }
+        if (tools)
+            for (const t of tools)
+                total += estimate(JSON.stringify(t));
+        const padded = Math.ceil(total * 1.25) + 1024;
+        let nc = 8192;
+        while (nc < padded && nc < 32768)
+            nc *= 2;
+        return Math.min(nc, 32768);
+    }
     convertMessages(messages, systemPrompt) {
         const converted = [];
         if (systemPrompt) {
@@ -69,6 +108,7 @@ export class OllamaProvider {
             model: m,
             messages: msgs,
             stream: true,
+            options: { num_ctx: this.computeNumCtx(messages, systemPrompt, tools) },
         };
         const ollamaTools = this.convertTools(tools);
         if (ollamaTools)
@@ -219,6 +259,7 @@ export class OllamaProvider {
             model: m,
             messages: msgs,
             stream: false,
+            options: { num_ctx: this.computeNumCtx(messages, systemPrompt, tools) },
         };
         const ollamaTools = this.convertTools(tools);
         if (ollamaTools)

package/dist/query/tools.js

@@ -42,11 +42,12 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
     // Permission check
     const perm = checkPermission(permissionMode, tool.riskLevel, tool.isReadOnly(parsed.data), tool.name, parsed.data);
     if (!perm.allowed) {
-        if (perm.reason === "needs-approval" && askUser) {
-            const { formatToolArgs } = await import("../utils/tool-summary.js");
-            const description = formatToolArgs(tool.name, toolCall.arguments);
-            // Hook: permissionRequest — fires between preToolUse and the interactive askUser prompt.
-            // Only fires when checkPermission says "needs-approval" AND askUser is provided.
+        if (perm.reason === "needs-approval") {
+            // Hook: permissionRequest — fires whenever checkPermission says
+            // "needs-approval", in both interactive and headless modes. Configured
+            // hooks get first say; if they return "ask" or have no decision, we
+            // fall through to the interactive prompt when one is available, or
+            // fail-closed deny in headless mode (issue #62).
             const hookOutcome = await emitHookWithOutcome("permissionRequest", {
                 toolName: tool.name,
                 toolArgs: JSON.stringify(toolCall.arguments).slice(0, 1000),
@@ -55,19 +56,30 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
                 permissionAction: "ask",
             });
             if (hookOutcome.permissionDecision === "allow") {
-                // Hook granted permission — skip interactive prompt and proceed to execution.
+                // Hook granted permission — proceed to execution.
             }
             else if (hookOutcome.permissionDecision === "deny" || !hookOutcome.allowed) {
                 const reason = hookOutcome.reason ? `: ${hookOutcome.reason}` : "";
                 return { output: `Permission denied by hook${reason}`, isError: true };
             }
-            else {
-                // "ask" or no decision → fall through to interactive prompt
+            else if (askUser) {
+                // "ask" or no decision → interactive prompt when available
+                const { formatToolArgs } = await import("../utils/tool-summary.js");
+                const description = formatToolArgs(tool.name, toolCall.arguments);
                 const allowed = await askUser(tool.name, description, tool.riskLevel);
                 if (!allowed) {
                     return { output: "Permission denied by user.", isError: true };
                 }
             }
+            else {
+                // Headless mode with no hook decision and no interactive prompt:
+                // fail-closed deny. SDK consumers should configure a permissionRequest
+                // hook (or use canUseTool) to make per-call decisions.
+                return {
+                    output: "Permission denied: needs-approval (no interactive prompt available; configure a permissionRequest hook to gate this tool)",
+                    isError: true,
+                };
+            }
         }
         else {
             return { output: `Permission denied: ${perm.reason}`, isError: true };

package/dist/tools/ListMcpResourcesTool/index.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    server: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    server?: string | undefined;
+}, {
+    server?: string | undefined;
+}>;
+export type McpResourceEntry = {
+    server: string;
+    uri: string;
+    name: string;
+    description?: string;
+};
+/**
+ * Pure formatter — renders the resource list as a markdown table.
+ * Exported for testing; production callers should use the tool's `.call()`.
+ */
+export declare function formatResourcesList(resources: McpResourceEntry[], serverFilter?: string): string;
+export declare const ListMcpResourcesTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/ListMcpResourcesTool/index.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { listMcpResources } from "../../mcp/loader.js";
+const inputSchema = z.object({
+    server: z.string().optional(),
+});
+/**
+ * Pure formatter — renders the resource list as a markdown table.
+ * Exported for testing; production callers should use the tool's `.call()`.
+ */
+export function formatResourcesList(resources, serverFilter) {
+    const filtered = serverFilter ? resources.filter((r) => r.server === serverFilter) : resources;
+    if (filtered.length === 0) {
+        if (serverFilter) {
+            return `No MCP resources available from server '${serverFilter}'.`;
+        }
+        return "No MCP resources available. Connect an MCP server that exposes resources under mcpServers in .oh/config.yaml.";
+    }
+    const lines = ["| Server | URI | Name | Description |", "|--------|-----|------|-------------|"];
+    for (const r of filtered) {
+        const desc = (r.description ?? "").replace(/\|/g, "\\|").slice(0, 80);
+        const name = r.name.replace(/\|/g, "\\|");
+        const uri = r.uri.replace(/\|/g, "\\|");
+        lines.push(`| ${r.server} | ${uri} | ${name} | ${desc} |`);
+    }
+    return lines.join("\n");
+}
+export const ListMcpResourcesTool = {
+    name: "ListMcpResources",
+    description: "List resources exposed by connected MCP servers.",
+    inputSchema,
+    riskLevel: "low",
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
+    async call(input) {
+        try {
+            const resources = await listMcpResources();
+            return { output: formatResourcesList(resources, input.server), isError: false };
+        }
+        catch (err) {
+            return { output: `Error listing MCP resources: ${err.message}`, isError: true };
+        }
+    },
+    prompt() {
+        return `List resources exposed by connected MCP servers. Parameters:
+- server (string, optional): restrict to this server's resources.
+Returns a markdown table with columns: Server, URI, Name, Description. Use ReadMcpResource with a URI from the table to fetch the content. Resources are read-only data sources (docs, indices, state) — distinct from MCP tools, which are actions.`;
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools/ReadMcpResourceTool/index.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    uri: z.ZodString;
+    server: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    uri: string;
+    server?: string | undefined;
+}, {
+    uri: string;
+    server?: string | undefined;
+}>;
+/**
+ * Pure helper — truncates resource content to MAX_OUTPUT_CHARS with a
+ * trailing `[...truncated]` marker when exceeded. Exported for testing.
+ */
+export declare function formatResourceContent(content: string, maxChars?: number): string;
+export declare const ReadMcpResourceTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/ReadMcpResourceTool/index.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { readMcpResource } from "../../mcp/loader.js";
+const inputSchema = z.object({
+    uri: z.string(),
+    server: z.string().optional(),
+});
+const MAX_OUTPUT_CHARS = 50_000;
+/**
+ * Pure helper — truncates resource content to MAX_OUTPUT_CHARS with a
+ * trailing `[...truncated]` marker when exceeded. Exported for testing.
+ */
+export function formatResourceContent(content, maxChars = MAX_OUTPUT_CHARS) {
+    if (content.length <= maxChars)
+        return content;
+    return `${content.slice(0, maxChars)}\n[...truncated at ${maxChars} chars, original length ${content.length}]`;
+}
+export const ReadMcpResourceTool = {
+    name: "ReadMcpResource",
+    description: "Read a specific MCP resource by URI from a connected MCP server.",
+    inputSchema,
+    riskLevel: "low",
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
+    async call(input) {
+        try {
+            const content = await readMcpResource(input.uri, input.server);
+            if (content === null) {
+                const where = input.server ? ` from server '${input.server}'` : "";
+                return {
+                    output: `Resource '${input.uri}' not found${where}. Run ListMcpResources to see available URIs.`,
+                    isError: true,
+                };
+            }
+            return { output: formatResourceContent(content), isError: false };
+        }
+        catch (err) {
+            return { output: `Error reading MCP resource: ${err.message}`, isError: true };
+        }
+    },
+    prompt() {
+        return `Read a specific resource from an MCP server by URI. Parameters:
+- uri (string, required): the resource URI, as shown by ListMcpResources.
+- server (string, optional): restrict lookup to this server. When omitted, the first server whose readResource call succeeds is used.
+Output is truncated at ~50KB. For discovery, call ListMcpResources first to get URIs.`;
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools.js

@@ -23,6 +23,7 @@ import { GlobTool } from "./tools/GlobTool/index.js";
 import { GrepTool } from "./tools/GrepTool/index.js";
 import { ImageReadTool } from "./tools/ImageReadTool/index.js";
 import { KillProcessTool } from "./tools/KillProcessTool/index.js";
+import { ListMcpResourcesTool } from "./tools/ListMcpResourcesTool/index.js";
 import { LSTool } from "./tools/LSTool/index.js";
 import { MemoryTool } from "./tools/MemoryTool/index.js";
 import { MonitorTool } from "./tools/MonitorTool/index.js";
@@ -31,6 +32,7 @@ import { NotebookEditTool } from "./tools/NotebookEditTool/index.js";
 import { ParallelAgentTool } from "./tools/ParallelAgentTool/index.js";
 import { PipelineTool } from "./tools/PipelineTool/index.js";
 import { PowerShellTool } from "./tools/PowerShellTool/index.js";
+import { ReadMcpResourceTool } from "./tools/ReadMcpResourceTool/index.js";
 import { RemoteTriggerTool } from "./tools/RemoteTriggerTool/index.js";
 import { ScheduleWakeupTool } from "./tools/ScheduleWakeupTool/index.js";
 import { SendMessageTool } from "./tools/SendMessageTool/index.js";
@@ -106,6 +108,8 @@ export function getAllTools() {
         ScheduleWakeupTool,
         SessionSearchTool,
         TodoWriteTool,
+        ListMcpResourcesTool,
+        ReadMcpResourceTool,
     ];
     return [...core, ...extended.map((t) => new DeferredTool(t))];
 }

package/dist/utils/json-schema.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Minimal JSON Schema validator — covers the common subset sufficient for
+ * constraining LLM output in headless mode. Supported keywords:
+ *
+ *   - `type`: "string" | "number" | "integer" | "boolean" | "object" | "array" | "null"
+ *             (or an array of those for union types)
+ *   - `properties`: object → sub-schema per field
+ *   - `required`: array of field names that must be present
+ *   - `items`: sub-schema for array elements
+ *   - `enum`: array of allowed literal values (compared with strict equality)
+ *
+ * Anything else is silently accepted. This is intentional — we don't want to
+ * ship a full JSON Schema engine. For cases that need more (e.g. `pattern`,
+ * `oneOf`, `$ref`), use an external validator.
+ */
+export type JsonSchema = Record<string, unknown>;
+export type ValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    errors: string[];
+};
+export declare function validateAgainstJsonSchema(value: unknown, schema: JsonSchema): ValidationResult;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/utils/json-schema.js

@@ -0,0 +1,110 @@
+/**
+ * Minimal JSON Schema validator — covers the common subset sufficient for
+ * constraining LLM output in headless mode. Supported keywords:
+ *
+ *   - `type`: "string" | "number" | "integer" | "boolean" | "object" | "array" | "null"
+ *             (or an array of those for union types)
+ *   - `properties`: object → sub-schema per field
+ *   - `required`: array of field names that must be present
+ *   - `items`: sub-schema for array elements
+ *   - `enum`: array of allowed literal values (compared with strict equality)
+ *
+ * Anything else is silently accepted. This is intentional — we don't want to
+ * ship a full JSON Schema engine. For cases that need more (e.g. `pattern`,
+ * `oneOf`, `$ref`), use an external validator.
+ */
+export function validateAgainstJsonSchema(value, schema) {
+    const errors = [];
+    validate(value, schema, "", errors);
+    return errors.length === 0 ? { ok: true } : { ok: false, errors };
+}
+function validate(value, schema, path, errors) {
+    if (schema.enum !== undefined && Array.isArray(schema.enum)) {
+        if (!schema.enum.some((allowed) => deepEqual(allowed, value))) {
+            errors.push(`${prefix(path)}value ${JSON.stringify(value)} is not one of the enum values`);
+            return;
+        }
+    }
+    if (schema.type !== undefined) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (!types.some((t) => matchesType(value, t))) {
+            errors.push(`${prefix(path)}expected ${types.join(" or ")}, got ${describeActual(value)}`);
+            return;
+        }
+    }
+    if (matchesType(value, "object") && schema.properties) {
+        const properties = schema.properties;
+        const required = schema.required ?? [];
+        const obj = value;
+        for (const field of required) {
+            if (!(field in obj)) {
+                const fullPath = path ? `${path}.${field}` : field;
+                errors.push(`missing required property '${fullPath}'`);
+            }
+        }
+        for (const [field, subSchema] of Object.entries(properties)) {
+            if (field in obj) {
+                validate(obj[field], subSchema, path ? `${path}.${field}` : field, errors);
+            }
+        }
+    }
+    if (matchesType(value, "array") && schema.items) {
+        const items = schema.items;
+        const arr = value;
+        arr.forEach((item, i) => {
+            validate(item, items, `${path}[${i}]`, errors);
+        });
+    }
+}
+function matchesType(value, type) {
+    switch (type) {
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "null":
+            return value === null;
+        case "array":
+            return Array.isArray(value);
+        case "object":
+            return typeof value === "object" && value !== null && !Array.isArray(value);
+        default:
+            return false;
+    }
+}
+function describeActual(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+function prefix(path) {
+    return path ? `${path}: ` : "";
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null)
+        return a === b;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((x, i) => deepEqual(x, b[i]));
+    }
+    if (typeof a === "object" && typeof b === "object") {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        return ka.every((k) => deepEqual(a[k], b[k]));
+    }
+    return false;
+}
+//# sourceMappingURL=json-schema.js.map

package/dist/utils/parse-budget.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parse the `--max-budget-usd` CLI argument into a positive USD amount.
+ *
+ * Accepts plain decimals (`5`, `0.50`, `2.5`) and an optional leading `$`.
+ * Negative or zero values are rejected — a budget of zero would block the
+ * very first call before any cost has accumulated.
+ *
+ * Returns `{ ok: true, value }` on success or `{ ok: false, message }` on
+ * invalid input. The CLI wrapper translates failures into a stderr message
+ * and exit code 2.
+ */
+export type ParseBudgetResult = {
+    ok: true;
+    value: number;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function parseMaxBudgetUsd(raw: string): ParseBudgetResult;
+//# sourceMappingURL=parse-budget.d.ts.map

package/dist/utils/parse-budget.js

@@ -0,0 +1,12 @@
+export function parseMaxBudgetUsd(raw) {
+    const cleaned = raw.replace(/^\$/, "").trim();
+    if (cleaned === "") {
+        return { ok: false, message: `--max-budget-usd must be a positive USD amount, got '${raw}'` };
+    }
+    const n = Number(cleaned);
+    if (!Number.isFinite(n) || n <= 0) {
+        return { ok: false, message: `--max-budget-usd must be a positive USD amount, got '${raw}'` };
+    }
+    return { ok: true, value: n };
+}
+//# sourceMappingURL=parse-budget.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.17.0",
+  "version": "2.19.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {
@@ -22,17 +22,23 @@
     "README.md",
     "LICENSE"
   ],
+  "workspaces": [
+    "packages/sdk"
+  ],
   "scripts": {
     "dev": "tsx src/main.tsx",
     "build": "tsc",
+    "build:sdk": "npm --workspace @zhijiewang/openharness-sdk run build",
     "prepare": "husky",
     "prepublishOnly": "npm run build",
-    "test": "node scripts/test.mjs",
+    "test": "node scripts/test.mjs && npm --workspace @zhijiewang/openharness-sdk run test",
+    "test:cli": "node scripts/test.mjs",
+    "test:sdk": "npm --workspace @zhijiewang/openharness-sdk run test",
     "test:coverage": "node scripts/coverage.mjs",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check src/",
-    "lint:fix": "biome check --write src/",
-    "format": "biome format --write src/",
+    "typecheck": "tsc --noEmit && npm --workspace @zhijiewang/openharness-sdk run typecheck",
+    "lint": "biome check src/ packages/sdk/src/",
+    "lint:fix": "biome check --write src/ packages/sdk/src/",
+    "format": "biome format --write src/ packages/sdk/src/",
     "start": "node dist/main.js"
   },
   "dependencies": {