@zhijiewang/openharness 2.14.0 → 2.15.0

package/README.md

@@ -57,6 +57,8 @@ oh
 
 That's it. OpenHarness auto-detects Ollama and starts chatting. No API key needed.
 
+**Python SDK:** there's also an official Python SDK for driving `oh` from Python programs (notebooks, batch scripts, ML pipelines). Install with `pip install openharness` after the npm install, then `from openharness import query`. See [`python/README.md`](python/README.md).
+
 ```bash
 oh init                               # interactive setup wizard (provider + cybergotchi)
 oh                                    # auto-detect local model

package/dist/main.js

@@ -230,7 +230,21 @@ program
                 console.log(JSON.stringify({ type: "error", message: event.message }));
             }
         }
+        else if (event.type === "cost_update") {
+            if (outputFormat === "stream-json") {
+                console.log(JSON.stringify({
+                    type: "cost_update",
+                    inputTokens: event.inputTokens,
+                    outputTokens: event.outputTokens,
+                    cost: event.cost,
+                    model: event.model,
+                }));
+            }
+        }
         else if (event.type === "turn_complete") {
+            if (outputFormat === "stream-json") {
+                console.log(JSON.stringify({ type: "turn_complete", reason: event.reason }));
+            }
             if (event.reason !== "completed") {
                 process.exitCode = 1;
             }
@@ -243,6 +257,138 @@ program
         process.stdout.write("\n");
     }
 });
+// ── `oh session`: long-lived stateful session for the Python SDK ──
+program
+    .command("session")
+    .description("Long-lived session: read JSON prompts from stdin, stream NDJSON events on stdout (for the Python SDK)")
+    .option("-m, --model <model>", "Model to use")
+    .addOption(new Option("--permission-mode <mode>", "Permission mode")
+    .choices(["ask", "trust", "deny", "acceptEdits", "plan", "auto", "bypassPermissions"])
+    .default("trust"))
+    .option("--allowed-tools <tools>", "Comma-separated allowed tool names")
+    .option("--disallowed-tools <tools>", "Comma-separated disallowed tool names")
+    .option("--max-turns <n>", "Maximum turns per prompt", "20")
+    .option("--system-prompt <prompt>", "Override the system prompt")
+    .action(async (opts) => {
+    const savedConfig = readOhConfig();
+    const permissionMode = (opts.permissionMode ??
+        savedConfig?.permissionMode ??
+        "trust");
+    const { createProvider } = await import("./providers/index.js");
+    const effectiveModel = opts.model ?? savedConfig?.model;
+    const overrides = {};
+    if (savedConfig?.apiKey)
+        overrides.apiKey = savedConfig.apiKey;
+    if (savedConfig?.baseUrl)
+        overrides.baseUrl = savedConfig.baseUrl;
+    const { provider, model } = await createProvider(effectiveModel, Object.keys(overrides).length ? overrides : undefined);
+    const { query } = await import("./query.js");
+    const { createAssistantMessage, createToolResultMessage, createUserMessage } = await import("./types/message.js");
+    let tools = getAllTools();
+    if (opts.allowedTools) {
+        const allowed = new Set(opts.allowedTools.split(",").map((s) => s.trim()));
+        tools = tools.filter((t) => allowed.has(t.name));
+    }
+    if (opts.disallowedTools) {
+        const disallowed = new Set(opts.disallowedTools.split(",").map((s) => s.trim()));
+        tools = tools.filter((t) => !disallowed.has(t.name));
+    }
+    const systemPrompt = opts.systemPrompt ?? buildSystemPrompt(model);
+    const config = {
+        provider,
+        tools,
+        systemPrompt,
+        permissionMode,
+        maxTurns: parseInt(opts.maxTurns, 10),
+        model,
+    };
+    // Conversation history, shared across all prompts for this process.
+    const conversation = [];
+    // Announce readiness so the client can send the first prompt.
+    console.log(JSON.stringify({ type: "ready" }));
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+    for await (const rawLine of rl) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            console.log(JSON.stringify({ id: "", type: "error", message: "invalid JSON on stdin" }));
+            continue;
+        }
+        if (request.command === "exit")
+            break;
+        const id = request.id ?? "";
+        const prompt = request.prompt;
+        if (!id || !prompt) {
+            console.log(JSON.stringify({ id, type: "error", message: "missing 'id' or 'prompt' field" }));
+            continue;
+        }
+        // Accumulate this turn's assistant output so we can push a full message at the end.
+        let assistantText = "";
+        const turnToolCalls = [];
+        const callIdToName = {};
+        const toolResults = [];
+        for await (const event of query(prompt, config, conversation)) {
+            if (event.type === "text_delta") {
+                assistantText += event.content;
+                console.log(JSON.stringify({ id, type: "text", content: event.content }));
+            }
+            else if (event.type === "tool_call_start") {
+                callIdToName[event.callId] = event.toolName;
+                console.log(JSON.stringify({ id, type: "tool_start", tool: event.toolName }));
+            }
+            else if (event.type === "tool_call_complete") {
+                turnToolCalls.push({
+                    id: event.callId,
+                    toolName: callIdToName[event.callId] ?? event.callId,
+                    arguments: event.arguments,
+                });
+            }
+            else if (event.type === "tool_call_end") {
+                toolResults.push({ callId: event.callId, output: event.output, isError: event.isError });
+                console.log(JSON.stringify({
+                    id,
+                    type: "tool_end",
+                    tool: callIdToName[event.callId],
+                    output: event.output,
+                    error: event.isError,
+                }));
+            }
+            else if (event.type === "error") {
+                console.log(JSON.stringify({ id, type: "error", message: event.message }));
+            }
+            else if (event.type === "cost_update") {
+                console.log(JSON.stringify({
+                    id,
+                    type: "cost_update",
+                    inputTokens: event.inputTokens,
+                    outputTokens: event.outputTokens,
+                    cost: event.cost,
+                    model: event.model,
+                }));
+            }
+            else if (event.type === "turn_complete") {
+                console.log(JSON.stringify({ id, type: "turn_complete", reason: event.reason }));
+            }
+        }
+        // Rebuild this turn's contribution to the conversation.
+        // The pattern mirrors query()'s internal accumulation at
+        // src/query/index.ts:119 (user msg pushed before turn) and 344 (assistant
+        // msg with tool calls pushed after each turn) — see the spec for detail.
+        conversation.push(createUserMessage(prompt));
+        if (assistantText || turnToolCalls.length > 0) {
+            conversation.push(createAssistantMessage(assistantText, turnToolCalls.length > 0 ? turnToolCalls : undefined));
+        }
+        for (const tr of toolResults) {
+            conversation.push(createToolResultMessage({ callId: tr.callId, output: tr.output, isError: tr.isError }));
+        }
+    }
+});
 // ── Default command: just run `openharness` to start chatting ──
 program
     .command("chat", { isDefault: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {