@inflexa-ai/harness 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inflexa-ai/harness",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
   "license": "Apache-2.0",
   "type": "module",
@@ -43,53 +43,53 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^4.0.5",
-    "@ai-sdk/openai-compatible": "^3.0.3",
-    "@ai-sdk/provider": "^4.0.1",
+    "@ai-sdk/anthropic": "^4.0.15",
+    "@ai-sdk/openai-compatible": "^3.0.10",
+    "@ai-sdk/provider": "^4.0.3",
     "@anthropic-ai/sdk": "^0.107.0",
-    "@dbos-inc/dbos-sdk": "^4.23.0",
-    "@kubernetes/client-node": "^1.0.0",
+    "@dbos-inc/dbos-sdk": "^4.23.6",
+    "@kubernetes/client-node": "^1.4.0",
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/core": "^2.8.0",
+    "@opentelemetry/core": "^2.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.219.0",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.219.0",
-    "@opentelemetry/resources": "^2.8.0",
-    "@opentelemetry/sdk-metrics": "^2.8.0",
-    "@opentelemetry/sdk-trace-base": "^2.8.0",
-    "@opentelemetry/sdk-trace-node": "^2.8.0",
-    "@opentelemetry/semantic-conventions": "^1.41.1",
-    "ai": "^7.0.11",
-    "cheerio": "^1.0.0",
-    "dockerode": "^4.0.0",
-    "fast-xml-parser": "^5.7.0",
-    "hono": "^4.0.0",
-    "js-tiktoken": "^1.0.0",
-    "mime": "^4.0.0",
-    "nanoid": "^5.0.0",
+    "@opentelemetry/resources": "^2.9.0",
+    "@opentelemetry/sdk-metrics": "^2.9.0",
+    "@opentelemetry/sdk-trace-base": "^2.9.0",
+    "@opentelemetry/sdk-trace-node": "^2.9.0",
+    "@opentelemetry/semantic-conventions": "^1.43.0",
+    "ai": "^7.0.28",
+    "cheerio": "^1.2.0",
+    "dockerode": "^4.0.12",
+    "fast-xml-parser": "^5.10.0",
+    "hono": "^4.12.30",
+    "js-tiktoken": "^1.0.21",
+    "mime": "^4.1.0",
+    "nanoid": "^5.1.16",
     "neverthrow": "^8.2.0",
     "nunjucks": "^3.2.4",
-    "openai": "^4.77.0",
-    "pdf-parse": "^2.4.0",
-    "pg": "^8.13.0",
+    "openai": "^4.104.0",
+    "pdf-parse": "^2.4.5",
+    "pg": "^8.22.0",
     "pino": "^10.3.1",
-    "puppeteer-core": "^23.0.0",
+    "puppeteer-core": "^23.11.1",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/bun": "latest",
-    "@types/dockerode": "^3.3.0",
-    "@types/node": "^24.0.0",
+    "@types/dockerode": "^3.3.47",
+    "@types/node": "^24.13.3",
     "@types/nunjucks": "^3.2.6",
-    "@types/pdf-parse": "^1.1.4",
-    "@types/pg": "^8.11.0",
-    "eslint": "^10.4.1",
+    "@types/pdf-parse": "^1.1.5",
+    "@types/pg": "^8.20.0",
+    "eslint": "^10.7.0",
     "eslint-plugin-neverthrow": "^1.1.4",
-    "globals": "^17.6.0",
-    "prettier": "^3.8.1",
-    "testcontainers": "^10.0.0",
+    "globals": "^17.7.0",
+    "prettier": "^3.9.5",
+    "testcontainers": "^10.28.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.61.0"
+    "typescript-eslint": "^8.64.0"
   },
   "publishConfig": {
     "access": "public",

package/dist/execution/filesystem-artifact-registry.d.ts

@@ -1,57 +0,0 @@
-/**
- * `FilesystemArtifactRegistry` — the harness's (cloud-free) `ArtifactRegistry`
- * adapter.
- *
- * Instead of registering provenance with an external ledger, it writes a local
- * provenance index file under the step directory:
- *
- *   {sessionPath}/{resourceId}/runs/{runId}/{stepId}/provenance-index.json
- *
- * The index records the step's registered artifacts (analysis-scoped paths +
- * hashes) and the tracked inputs/outputs captured by the `ProvenanceCollector`,
- * so a local embedder (the CLI) retains a queryable lineage record with no
- * cloud dependency. Re-registration merges by output path (latest wins).
- *
- * It returns no external ids — the local `cortex_artifacts` ledger is the only
- * identity store in the cloud-free configuration.
- */
-import type { ArtifactRegistry } from "./artifact-registry.js";
-export interface FilesystemArtifactRegistryDeps {
-    /** Base path holding per-analysis session directories. */
-    sessionPath: string;
-}
-/** One registered artifact in the local index. */
-export interface FilesystemArtifactEntry {
-    /** Analysis-scoped path (`runs/{runId}/{stepId}/...`). */
-    path: string;
-    hash: string;
-    size: number;
-    type: string;
-}
-/** One tracked output's lineage in the local index. */
-export interface FilesystemLineageRecord {
-    outputPath: string;
-    outputHash: string;
-    producer: string;
-    scriptPath: string | null;
-    inputs: Array<{
-        path: string;
-        hash: string;
-        source: string;
-    }>;
-}
-/** Shape of the persisted provenance index file. */
-export interface FilesystemProvenanceIndex {
-    resourceId: string;
-    runId: string;
-    stepId: string;
-    updatedAt: string;
-    artifacts: FilesystemArtifactEntry[];
-    inputs: Array<{
-        path: string;
-        hash: string;
-        source: string;
-    }>;
-    lineage: FilesystemLineageRecord[];
-}
-export declare function createFilesystemArtifactRegistry(deps: FilesystemArtifactRegistryDeps): ArtifactRegistry;

package/dist/execution/filesystem-artifact-registry.js

@@ -1,92 +0,0 @@
-/**
- * `FilesystemArtifactRegistry` — the harness's (cloud-free) `ArtifactRegistry`
- * adapter.
- *
- * Instead of registering provenance with an external ledger, it writes a local
- * provenance index file under the step directory:
- *
- *   {sessionPath}/{resourceId}/runs/{runId}/{stepId}/provenance-index.json
- *
- * The index records the step's registered artifacts (analysis-scoped paths +
- * hashes) and the tracked inputs/outputs captured by the `ProvenanceCollector`,
- * so a local embedder (the CLI) retains a queryable lineage record with no
- * cloud dependency. Re-registration merges by output path (latest wins).
- *
- * It returns no external ids — the local `cortex_artifacts` ledger is the only
- * identity store in the cloud-free configuration.
- */
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { runStepDir } from "../workspace/paths.js";
-function indexPath(sessionPath, input) {
-    return join(sessionPath, runStepDir(input.resourceId, input.runId, input.stepId), "provenance-index.json");
-}
-async function readIndex(path) {
-    try {
-        return JSON.parse(await readFile(path, "utf8"));
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return null;
-        // Corrupt/partial index (e.g. crash mid-write) → treat as absent and rebuild.
-        if (err instanceof SyntaxError)
-            return null;
-        throw err;
-    }
-}
-/** Merge two keyed lists, latest (incoming) winning per key. */
-function mergeBy(prior, incoming, key) {
-    const byKey = new Map();
-    for (const item of prior)
-        byKey.set(key(item), item);
-    for (const item of incoming)
-        byKey.set(key(item), item);
-    return [...byKey.values()];
-}
-export function createFilesystemArtifactRegistry(deps) {
-    const { sessionPath } = deps;
-    return {
-        async register(input, _session) {
-            const { runId, stepId, artifacts, collector } = input;
-            if (artifacts.length === 0) {
-                return { registered: [], failed: [], failedCount: 0 };
-            }
-            const dbPathPrefix = `runs/${runId}/${stepId}/`;
-            const entries = artifacts.map((a) => ({
-                path: `${dbPathPrefix}${a.path}`,
-                hash: a.hash ?? "",
-                size: a.size,
-                type: a.type,
-            }));
-            const inputs = collector.getTrackedInputs().map((i) => ({
-                path: i.path,
-                hash: i.hash,
-                source: i.source,
-            }));
-            const lineage = collector.getRecords().map((r) => ({
-                outputPath: r.outputPath,
-                outputHash: r.outputHash,
-                producer: r.producer.type,
-                scriptPath: r.scriptPath,
-                inputs: r.inputs.map((i) => ({ path: i.path, hash: i.hash, source: i.source })),
-            }));
-            const path = indexPath(sessionPath, input);
-            const prior = await readIndex(path);
-            const merged = {
-                resourceId: input.resourceId,
-                runId,
-                stepId,
-                updatedAt: new Date().toISOString(),
-                artifacts: mergeBy(prior?.artifacts ?? [], entries, (e) => e.path),
-                inputs: mergeBy(prior?.inputs ?? [], inputs, (i) => i.path),
-                lineage: mergeBy(prior?.lineage ?? [], lineage, (l) => l.outputPath),
-            };
-            await mkdir(dirname(path), { recursive: true });
-            await writeFile(path, JSON.stringify(merged, null, 2));
-            // No external identity store in the cloud-free configuration.
-            return { registered: [], failed: [], failedCount: 0 };
-        },
-        // Bytes already live in the local session tree — nothing to upload.
-        async sync() { },
-    };
-}

package/dist/lib/identifiers.d.ts

@@ -1,8 +0,0 @@
-/**
- * Identifier validation — safe patterns for path-embedded IDs.
- */
-/** Pattern for IDs safe to embed in filesystem paths. */
-export declare const SAFE_ID_PATTERN: RegExp;
-/** Zod refinement for safe path identifiers. */
-export declare function isSafePathId(value: string): boolean;
-export declare const SAFE_ID_MESSAGE = "Must be alphanumeric with hyphens/underscores, no path separators";

package/dist/lib/identifiers.js

@@ -1,10 +0,0 @@
-/**
- * Identifier validation — safe patterns for path-embedded IDs.
- */
-/** Pattern for IDs safe to embed in filesystem paths. */
-export const SAFE_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
-/** Zod refinement for safe path identifiers. */
-export function isSafePathId(value) {
-    return SAFE_ID_PATTERN.test(value) && !value.includes("..");
-}
-export const SAFE_ID_MESSAGE = "Must be alphanumeric with hyphens/underscores, no path separators";

package/dist/lib/mime-detect.d.ts

@@ -1,17 +0,0 @@
-/**
- * Mime-type detection for artifact registration.
- *
- * Registration payloads sent to the storage backend carry a `mimeType` per file. The storage backend
- * persists it on the artifact row and uses it as the S3 object's
- * `Content-Type` when the artifact is later synced — without it, S3 stores
- * `application/octet-stream` and downloads serve as opaque binary regardless
- * of file extension.
- *
- * The `mime` package's mime-db backing doesn't include a few science-domain
- * extensions (`.py`, `.R`, `.Rmd`, `.RData`, `.rds`) that browsers populate
- * in `File.type` from their bundled tables, so we extend a custom Mime
- * instance with those cases. Returned types align with the frontend's browser-side
- * detection so a Python script uploaded directly and one synced from a
- * sandbox both end up with the same `text/x-python`.
- */
-export declare function detectMimeType(pathOrFilename: string): string;

package/dist/lib/mime-detect.js

@@ -1,29 +0,0 @@
-/**
- * Mime-type detection for artifact registration.
- *
- * Registration payloads sent to the storage backend carry a `mimeType` per file. The storage backend
- * persists it on the artifact row and uses it as the S3 object's
- * `Content-Type` when the artifact is later synced — without it, S3 stores
- * `application/octet-stream` and downloads serve as opaque binary regardless
- * of file extension.
- *
- * The `mime` package's mime-db backing doesn't include a few science-domain
- * extensions (`.py`, `.R`, `.Rmd`, `.RData`, `.rds`) that browsers populate
- * in `File.type` from their bundled tables, so we extend a custom Mime
- * instance with those cases. Returned types align with the frontend's browser-side
- * detection so a Python script uploaded directly and one synced from a
- * sandbox both end up with the same `text/x-python`.
- */
-import { Mime } from "mime";
-import standard from "mime/types/standard.js";
-import other from "mime/types/other.js";
-const mime = new Mime(standard, other, {
-    "text/x-python": ["py"],
-    "text/x-r-source": ["R", "r"],
-    "text/x-r-markdown": ["Rmd", "rmd"],
-    "application/x-rdata": ["RData", "Rdata", "rds"],
-});
-const FALLBACK = "application/octet-stream";
-export function detectMimeType(pathOrFilename) {
-    return mime.getType(pathOrFilename) ?? FALLBACK;
-}

package/dist/lib/streamed-download.d.ts

@@ -1,28 +0,0 @@
-/**
- * Streaming HTTP download helper with optional ranged-GET parallelism.
- *
- * Per-stream working memory is bounded at ~64 KiB regardless of file size —
- * bodies are never materialized as Buffers. When the caller supplies the
- * total size and it exceeds `partSize`, the download is split into N ranged
- * GETs that write into a pre-allocated file at their respective offsets.
- */
-export interface StreamDownloadOpts {
-    /** Total file size. Required for ranged-parallel downloads. */
-    size?: number;
-    /** Bytes per range. Falls back to single-GET when size <= partSize. */
-    partSize?: number;
-    /** Max ranges in flight. */
-    concurrency?: number;
-    /** Max retries per range or per whole-file stream. */
-    maxRetries?: number;
-    /** Abort signal for cancellation. */
-    signal?: AbortSignal;
-}
-/**
- * Download a URL to `destPath`, streaming the body to disk.
- *
- * Creates the destination file (truncating any existing content). On success
- * the file exists at `destPath`; on failure it may be partially written —
- * callers should use a temp path + rename pattern if atomicity matters.
- */
-export declare function streamDownload(url: string, destPath: string, opts?: StreamDownloadOpts): Promise<void>;

package/dist/lib/streamed-download.js

@@ -1,111 +0,0 @@
-/**
- * Streaming HTTP download helper with optional ranged-GET parallelism.
- *
- * Per-stream working memory is bounded at ~64 KiB regardless of file size —
- * bodies are never materialized as Buffers. When the caller supplies the
- * total size and it exceeds `partSize`, the download is split into N ranged
- * GETs that write into a pre-allocated file at their respective offsets.
- */
-import { createWriteStream } from "node:fs";
-import { open as fsOpen } from "node:fs/promises";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { mapConcurrent, sleep } from "./async-utils.js";
-const DEFAULT_PART_SIZE = 32 * 1024 * 1024; // 32 MiB
-const DEFAULT_CONCURRENCY = 4;
-const DEFAULT_MAX_RETRIES = 3;
-const BASE_DELAY_MS = 500;
-/**
- * Download a URL to `destPath`, streaming the body to disk.
- *
- * Creates the destination file (truncating any existing content). On success
- * the file exists at `destPath`; on failure it may be partially written —
- * callers should use a temp path + rename pattern if atomicity matters.
- */
-export async function streamDownload(url, destPath, opts = {}) {
-    const size = opts.size;
-    const partSize = opts.partSize ?? DEFAULT_PART_SIZE;
-    const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY;
-    const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
-    if (!size || size <= partSize) {
-        await fetchStreamToFile(url, destPath, "w", undefined, maxRetries, opts.signal);
-        return;
-    }
-    // Pre-allocate the file so per-range streams can write at correct offsets.
-    const fh = await fsOpen(destPath, "w");
-    try {
-        await fh.truncate(size);
-    }
-    finally {
-        await fh.close();
-    }
-    const totalParts = Math.ceil(size / partSize);
-    await mapConcurrent(Array.from({ length: totalParts }, (_, i) => i), concurrency, async (i) => {
-        const start = i * partSize;
-        const end = Math.min(start + partSize, size) - 1;
-        await fetchRangeToFile(url, destPath, start, end, maxRetries, opts.signal);
-    });
-}
-async function fetchStreamToFile(url, destPath, flags, start, maxRetries, signal) {
-    let lastError = "";
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            const res = await fetch(url, { signal });
-            if (!res.ok) {
-                lastError = `HTTP ${res.status}`;
-                if (res.status >= 500 && attempt < maxRetries - 1) {
-                    await sleep(BASE_DELAY_MS * 2 ** attempt);
-                    continue;
-                }
-                throw new Error(lastError);
-            }
-            if (!res.body)
-                throw new Error("response body is null");
-            const writer = createWriteStream(destPath, start !== undefined ? { flags, start } : { flags });
-            await pipeline(Readable.fromWeb(res.body), writer);
-            return;
-        }
-        catch (err) {
-            lastError = err instanceof Error ? err.message : String(err);
-            if (attempt < maxRetries - 1) {
-                await sleep(BASE_DELAY_MS * 2 ** attempt);
-                continue;
-            }
-        }
-    }
-    throw new Error(`download failed after ${maxRetries} attempts: ${lastError}`);
-}
-async function fetchRangeToFile(url, destPath, start, end, maxRetries, signal) {
-    let lastError = "";
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            const res = await fetch(url, {
-                headers: { Range: `bytes=${start}-${end}` },
-                signal,
-            });
-            // 206 is the expected success; 200 means the server ignored Range — treat
-            // as fatal since it would overwrite other ranges.
-            if (res.status !== 206) {
-                lastError = `HTTP ${res.status}`;
-                if (res.status >= 500 && attempt < maxRetries - 1) {
-                    await sleep(BASE_DELAY_MS * 2 ** attempt);
-                    continue;
-                }
-                throw new Error(res.status === 200 ? `server ignored Range header (HTTP 200) — parallel download would clobber` : lastError);
-            }
-            if (!res.body)
-                throw new Error("response body is null");
-            const writer = createWriteStream(destPath, { flags: "r+", start });
-            await pipeline(Readable.fromWeb(res.body), writer);
-            return;
-        }
-        catch (err) {
-            lastError = err instanceof Error ? err.message : String(err);
-            if (attempt < maxRetries - 1) {
-                await sleep(BASE_DELAY_MS * 2 ** attempt);
-                continue;
-            }
-        }
-    }
-    throw new Error(`range ${start}-${end} failed after ${maxRetries} attempts: ${lastError}`);
-}

package/dist/lib/trace-context.d.ts

@@ -1,11 +0,0 @@
-/**
- * Hono middleware for W3C Trace Context extraction.
- *
- * Hono's HTTP server is not auto-instrumented by OTEL (which patches Node's
- * `http` module, not Hono's request handling). This middleware manually
- * extracts the `traceparent` header from incoming requests, creates an OTEL
- * server span, and wraps the handler in `context.with()` so the OtelBridge
- * and any downstream code see the correct parent span via `context.active()`.
- */
-import type { MiddlewareHandler } from "hono";
-export declare const traceContextMiddleware: MiddlewareHandler;

package/dist/lib/trace-context.js

@@ -1,49 +0,0 @@
-/**
- * Hono middleware for W3C Trace Context extraction.
- *
- * Hono's HTTP server is not auto-instrumented by OTEL (which patches Node's
- * `http` module, not Hono's request handling). This middleware manually
- * extracts the `traceparent` header from incoming requests, creates an OTEL
- * server span, and wraps the handler in `context.with()` so the OtelBridge
- * and any downstream code see the correct parent span via `context.active()`.
- */
-import { trace, context, propagation, SpanKind, SpanStatusCode } from "@opentelemetry/api";
-const tracer = trace.getTracer("cortex.http");
-/**
- * Middleware that extracts W3C trace context from incoming HTTP headers and
- * creates a server span. Must be registered before all other middleware so
- * the OTEL context is available throughout the request lifecycle.
- */
-const SKIP_TRACE_PATHS = new Set(["/healthz", "/readyz"]);
-export const traceContextMiddleware = async (c, next) => {
-    if (SKIP_TRACE_PATHS.has(c.req.path)) {
-        return next();
-    }
-    const carrier = {};
-    for (const [key, value] of c.req.raw.headers) {
-        carrier[key] = value;
-    }
-    const parentCtx = propagation.extract(context.active(), carrier);
-    const span = tracer.startSpan(`${c.req.method} ${c.req.path}`, {
-        kind: SpanKind.SERVER,
-        attributes: {
-            "http.method": c.req.method,
-            "http.target": c.req.path,
-        },
-    }, parentCtx);
-    const spanCtx = trace.setSpan(parentCtx, span);
-    try {
-        await context.with(spanCtx, () => next());
-        span.setAttribute("http.status_code", c.res.status);
-    }
-    catch (err) {
-        span.setStatus({ code: SpanStatusCode.ERROR });
-        if (err instanceof Error) {
-            span.recordException(err);
-        }
-        throw err;
-    }
-    finally {
-        span.end();
-    }
-};

package/dist/providers/llm-capabilities.d.ts

@@ -1,33 +0,0 @@
-/**
- * Per-model capability gates for harness provider calls.
- *
- * The harness `ChatRequest` is a passthrough of `MessageCreateParamsBase`,
- * so callers already pass per-call overrides (`temperature`, `thinking`,
- * tool config, …) as native fields. This module is the silent drop-on-reject
- * gate at the provider edge: model-rejected fields are stripped before they
- * hit the wire so the call still succeeds (e.g. `acceptsTemperature`).
- *
- * Classification is pattern-based on the bare model name (no provider
- * prefix — the harness `createAnthropicProvider` already knows it is
- * Anthropic). No network calls, no runtime probing.
- */
-import type { Message } from "./types.js";
-/**
- * Anthropic Opus/Sonnet/Haiku 4.7+ reject `temperature` with HTTP 400.
- * 4.6 and earlier accept it.
- */
-export declare function anthropicAcceptsTemperature(modelName: string): boolean;
-/**
- * The model's true maximum output-token ceiling — the `max_tokens` the
- * Anthropic provider sets per call (the API requires the field). Pattern-
- * matched on the bare model name (no provider prefix). Ceilings per the
- * current Anthropic model reference: Opus 4.x → 128K, Sonnet 4.6 → 64K,
- * Haiku 4.5 → 64K.
- */
-export declare function maxOutputTokens(modelName: string): number;
-/**
- * Map an OpenAI `finish_reason` into the Anthropic `stop_reason` the harness
- * loop branches on (see the harness-providers spec — every provider adapts into Anthropic shape).
- * The imminent `openai.ts` adapter is the first caller.
- */
-export declare function mapOpenAiFinishReason(finishReason: string | null): Message["stop_reason"];

package/dist/providers/llm-capabilities.js

@@ -1,58 +0,0 @@
-/**
- * Per-model capability gates for harness provider calls.
- *
- * The harness `ChatRequest` is a passthrough of `MessageCreateParamsBase`,
- * so callers already pass per-call overrides (`temperature`, `thinking`,
- * tool config, …) as native fields. This module is the silent drop-on-reject
- * gate at the provider edge: model-rejected fields are stripped before they
- * hit the wire so the call still succeeds (e.g. `acceptsTemperature`).
- *
- * Classification is pattern-based on the bare model name (no provider
- * prefix — the harness `createAnthropicProvider` already knows it is
- * Anthropic). No network calls, no runtime probing.
- */
-/**
- * Anthropic Opus/Sonnet/Haiku 4.7+ reject `temperature` with HTTP 400.
- * 4.6 and earlier accept it.
- */
-export function anthropicAcceptsTemperature(modelName) {
-    return !/^claude-(opus|sonnet|haiku)-4-([7-9]|\d{2,})\b/.test(modelName.toLowerCase());
-}
-/**
- * The model's true maximum output-token ceiling — the `max_tokens` the
- * Anthropic provider sets per call (the API requires the field). Pattern-
- * matched on the bare model name (no provider prefix). Ceilings per the
- * current Anthropic model reference: Opus 4.x → 128K, Sonnet 4.6 → 64K,
- * Haiku 4.5 → 64K.
- */
-export function maxOutputTokens(modelName) {
-    const name = modelName.toLowerCase();
-    if (/^claude-opus-4-/.test(name))
-        return 128_000;
-    if (/^claude-sonnet-4-/.test(name))
-        return 64_000;
-    if (/^claude-haiku-4-/.test(name))
-        return 64_000;
-    // Unknown model — a generous default broadly accepted by current models;
-    // the loop recovers from truncation, so erring high is cheap.
-    return 32_768;
-}
-/**
- * Map an OpenAI `finish_reason` into the Anthropic `stop_reason` the harness
- * loop branches on (see the harness-providers spec — every provider adapts into Anthropic shape).
- * The imminent `openai.ts` adapter is the first caller.
- */
-export function mapOpenAiFinishReason(finishReason) {
-    switch (finishReason) {
-        case "length":
-            return "max_tokens";
-        case "tool_calls":
-            return "tool_use";
-        case "stop":
-            return "end_turn";
-        case "content_filter":
-            return "refusal";
-        default:
-            return "end_turn";
-    }
-}

package/dist/schemas/render-step-prompt.d.ts

@@ -1,32 +0,0 @@
-/**
- * Render an AnalysisStep into the user-content prompt the sandbox agent
- * receives as its initial message.
- *
- * The planner writes the bulk of a step's instructions into structured
- * fields (`constraints`, `acceptance_criteria`, `context`, `caveats`,
- * `description`) alongside the one-line `question`. The execution path
- * forwards a single `prompt` string to the sandbox agent, so every
- * instruction-bearing field must be folded into that string here — otherwise
- * the agent runs against the bare question and improvises the rest.
- *
- * `STEP_PROMPT_INSTRUCTION_FIELDS` / `STEP_PROMPT_NON_INSTRUCTION_FIELDS`
- * partition every AnalysisStep field so the field-coverage guard test can
- * fail when a new field is added to the schema without a deliberate decision
- * about whether the agent needs to see it.
- */
-import type { AnalysisStep } from "./workflow-state.js";
-/** Fields whose content is agent-facing and MUST appear in the rendered prompt. */
-export declare const STEP_PROMPT_INSTRUCTION_FIELDS: readonly ["name", "question", "description", "context", "constraints", "acceptance_criteria", "caveats"];
-/**
- * Fields deliberately excluded from the prompt: identity/DAG structure
- * threaded separately through the workflow input, execution knobs, and
- * result fields populated after the step runs.
- */
-export declare const STEP_PROMPT_NON_INSTRUCTION_FIELDS: readonly ["id", "track", "step_type", "depends_on", "status", "resources", "agent", "timeout", "maxSteps", "summary", "artifactIds", "error"];
-/**
- * Compose the agent's initial prompt from a plan step. Only the `question`
- * is guaranteed present; the remaining instruction fields are appended as
- * dedicated sections when populated. Empty strings and empty arrays are
- * skipped so a sparse step renders cleanly.
- */
-export declare function renderStepPrompt(step: AnalysisStep): string;