@openpond/harness 0.2.6 → 0.3.0

package/dist/source-execution.js

@@ -0,0 +1,65 @@
+import { runProviderRoundLoop } from "./provider-loop.js";
+import { HARNESS_SOURCE_READ_TOOL_NAME } from "./source-runtime.js";
+/** Shared rollout lifecycle. Hosts own model transport, environment effects and
+ * grading; this runtime owns released resource calls and conversation history. */
+export async function executeHarnessRollout(input) {
+    const messages = [
+        { role: "system", content: input.runtime?.systemPrompt ?? input.systemPrompt },
+        { role: "user", content: input.userPrompt },
+    ];
+    const tools = [...input.tools, ...(input.runtime?.tools ?? [])];
+    const policyResults = [];
+    const toolSequence = [];
+    const trace = [];
+    const finalStep = await runProviderRoundLoop({
+        turnId: input.turnId,
+        maxRounds: input.maxTurns,
+        signal: input.signal,
+        async runRound({ index: turnIndex, signal }) {
+            // Transport receives owned messages so a host cannot mutate retained history.
+            const completion = await input.policyRequest({ turnIndex, messages: structuredClone(messages), tools: structuredClone(tools) }, signal);
+            signal.throwIfAborted();
+            policyResults.push(completion.result);
+            messages.push({ role: "assistant", content: completion.content,
+                tool_calls: completion.toolCalls.map(call => ({ id: call.id, type: "function", function: { name: call.name, arguments: call.arguments } })) });
+            const sourceCalls = input.runtime ? completion.toolCalls.filter(call => call.name === HARNESS_SOURCE_READ_TOOL_NAME) : [];
+            const environmentCalls = input.runtime ? completion.toolCalls.filter(call => call.name !== HARNESS_SOURCE_READ_TOOL_NAME) : completion.toolCalls;
+            const sourceResults = sourceCalls.map(call => {
+                let output;
+                try {
+                    output = input.runtime.readFile(JSON.parse(call.arguments));
+                }
+                catch (error) {
+                    output = { error: error instanceof Error ? error.message : "Harness source read failed." };
+                }
+                messages.push({ role: "tool", tool_call_id: call.id, content: JSON.stringify(output) });
+                toolSequence.push(call.name);
+                return { id: call.id, name: call.name, output };
+            });
+            if (sourceCalls.length && !environmentCalls.length) {
+                trace.push({ turnIndex, content: completion.content, toolCalls: sourceCalls, toolResults: sourceResults, terminal: false });
+                return { type: "continue" };
+            }
+            const step = await input.step({ content: completion.content, toolCalls: environmentCalls }, signal);
+            signal.throwIfAborted();
+            for (const result of step.toolResults) {
+                messages.push({ role: "tool", tool_call_id: result.id, content: JSON.stringify(result.output) });
+                toolSequence.push(result.name);
+            }
+            if (step.userMessage)
+                messages.push({ role: "user", content: step.userMessage });
+            trace.push({ turnIndex, content: completion.content, toolCalls: completion.toolCalls,
+                toolResults: [...sourceResults, ...step.toolResults], terminal: step.terminal });
+            return step.terminal ? { type: "complete", result: step } : { type: "continue" };
+        },
+        async onExhausted() {
+            input.signal.throwIfAborted();
+            const step = await input.terminate("max_turns", input.signal);
+            if (!step.terminal)
+                throw new Error("Harness environment did not terminate after exhausting its turn budget.");
+            trace.push({ turnIndex: input.maxTurns, content: null, toolCalls: [], toolResults: [], terminal: true, terminationReason: "max_turns" });
+            return step;
+        },
+    });
+    return { messages, toolSequence, trace, policyResults, finalStep, runtimeReceipt: input.runtime?.receipt ?? null };
+}

package/dist/source-package.js

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { assertContentHash, contentHash, ImmutableAssetRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema, sha256, } from "./common.js";
+import { AgentSnapshotSchema, HarnessReleaseSchema } from "./harness.js";
+export const MAX_HARNESS_SOURCE_PACKAGE_BYTES = 25 * 1024 * 1024;
+const HarnessSourceFileSchema = z.object({
+    path: ImmutableAssetRefSchema.shape.path,
+    base64: z.string().max(Math.ceil(MAX_HARNESS_SOURCE_PACKAGE_BYTES / 3) * 4),
+}).strict();
+const HarnessSourcePackageContentSchema = z.object({
+    schemaVersion: z.literal("openpond.harnessSourcePackage.v1"),
+    agentSnapshot: AgentSnapshotSchema,
+    harnessRelease: HarnessReleaseSchema,
+    files: z.array(HarnessSourceFileSchema).max(10_000),
+}).strict();
+export const HarnessSourcePackageSchema = HarnessSourcePackageContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const HarnessSourceSelectionSchema = z.object({
+    schemaVersion: z.literal("openpond.harnessSourceSelection.v1"),
+    mode: z.enum(["taskset_owned", "selected_release"]),
+    harnessRelease: ImmutableReleaseRefSchema,
+    sourcePackageHash: ReleaseHashSchema.nullable(),
+}).strict().superRefine((selection, context) => {
+    if ((selection.mode === "selected_release") !== (selection.sourcePackageHash !== null)) {
+        context.addIssue({ code: "custom", path: ["sourcePackageHash"], message: "Only a selected release binds a source package." });
+    }
+});
+/** Resolve the source selected by a captured bundle; missing source cannot be
+ * interpreted as Taskset-owned execution when the bundle selected a release. */
+export function resolveHarnessSourceSelection(input) {
+    const selection = HarnessSourceSelectionSchema.parse(input.selection);
+    if (selection.harnessRelease.id !== input.expectedRelease.id
+        || selection.harnessRelease.contentHash !== input.expectedRelease.contentHash) {
+        throw new Error("Harness source selection differs from its run manifest.");
+    }
+    if (selection.mode === "taskset_owned") {
+        if (input.sourcePackage !== undefined && input.sourcePackage !== null)
+            throw new Error("Taskset-owned execution cannot include a selected Harness source package.");
+        return { selection, sourcePackage: null };
+    }
+    const sourcePackage = validateHarnessSourcePackage(input.sourcePackage, selection.harnessRelease);
+    if (sourcePackage.contentHash !== selection.sourcePackageHash)
+        throw new Error("Harness source selection differs from its captured package.");
+    return { selection, sourcePackage };
+}
+/** Capture the full released source. Runtime admission separately authorizes
+ * export and capabilities; a source package never makes private files visible
+ * to a policy merely by transporting them. */
+export function createHarnessSourcePackage(input) {
+    if ([...input.files.values()].reduce((total, bytes) => total + bytes.byteLength, 0) > MAX_HARNESS_SOURCE_PACKAGE_BYTES) {
+        throw new Error("Harness source package exceeds its byte limit.");
+    }
+    const content = HarnessSourcePackageContentSchema.parse({
+        schemaVersion: "openpond.harnessSourcePackage.v1",
+        agentSnapshot: input.agentSnapshot,
+        harnessRelease: input.harnessRelease,
+        files: [...input.files].sort(([a], [b]) => a.localeCompare(b)).map(([path, bytes]) => ({
+            path,
+            base64: encode(bytes),
+        })),
+    });
+    return validateHarnessSourcePackage({ ...content, contentHash: contentHash(content) });
+}
+/** Validate both release objects, their complete asset closure and exact bytes.
+ * Rehashing the outer package cannot bless a substituted instruction or file. */
+export function validateHarnessSourcePackage(value, expected) {
+    const source = HarnessSourcePackageSchema.parse(value);
+    assertContentHash(source, "Harness source package");
+    assertContentHash(source.agentSnapshot, "Harness source Agent snapshot");
+    assertContentHash(source.harnessRelease, "Harness source release");
+    const { agentSnapshot, harnessRelease } = source;
+    if (expected && (expected.id !== harnessRelease.id || expected.contentHash !== harnessRelease.contentHash)) {
+        throw new Error("Harness source package differs from the selected release.");
+    }
+    if (harnessRelease.agentSnapshot.id !== agentSnapshot.id
+        || harnessRelease.agentSnapshot.contentHash !== agentSnapshot.contentHash) {
+        throw new Error("Harness source release does not bind its Agent snapshot.");
+    }
+    const assets = new Map();
+    const ids = new Set();
+    for (const asset of harnessRelease.files) {
+        if (asset.path.includes("\\") || asset.path.includes(":"))
+            throw new Error("Harness source requires portable relative file paths.");
+        if (assets.has(asset.path) || ids.has(asset.id))
+            throw new Error("Harness source contains duplicate asset paths or identities.");
+        assets.set(asset.path, asset);
+        ids.add(asset.id);
+    }
+    for (const asset of [harnessRelease.program, agentSnapshot.dependencyLock,
+        ...agentSnapshot.instructions, ...agentSnapshot.skills, ...agentSnapshot.agents]) {
+        if (contentHash(assets.get(asset.path) ?? null) !== contentHash(asset)) {
+            throw new Error(`Harness source dependency ${asset.path} is absent or differs from its release inventory.`);
+        }
+    }
+    for (const asset of [...agentSnapshot.instructions, ...agentSnapshot.skills]) {
+        if (asset.visibility !== "policy")
+            throw new Error(`Harness policy source ${asset.path} is private.`);
+    }
+    const paths = new Set();
+    let totalBytes = 0;
+    for (const file of source.files) {
+        if (paths.has(file.path))
+            throw new Error("Harness source package contains duplicate files.");
+        paths.add(file.path);
+        const asset = assets.get(file.path);
+        if (!asset)
+            throw new Error(`Harness source file ${file.path} is not declared by its release.`);
+        const bytes = decode(file.base64);
+        totalBytes += bytes.byteLength;
+        if (totalBytes > MAX_HARNESS_SOURCE_PACKAGE_BYTES)
+            throw new Error("Harness source package exceeds its byte limit.");
+        if (bytes.byteLength !== asset.sizeBytes || sha256(bytes) !== asset.contentHash) {
+            throw new Error(`Harness source file ${file.path} differs from its immutable bytes.`);
+        }
+    }
+    if (paths.size !== assets.size)
+        throw new Error("Harness source package is missing released files.");
+    return source;
+}
+/** Return an owned byte snapshot, including visibility in the release inventory.
+ * A runtime must select policy assets explicitly rather than expose this map. */
+export function harnessSourcePackageFiles(value, expected) {
+    const source = validateHarnessSourcePackage(value, expected);
+    return new Map(source.files.map(file => [file.path, decode(file.base64)]));
+}
+function encode(bytes) {
+    let binary = "";
+    for (let offset = 0; offset < bytes.length; offset += 8_192) {
+        binary += String.fromCharCode(...bytes.subarray(offset, offset + 8_192));
+    }
+    return btoa(binary);
+}
+function decode(base64) {
+    let binary;
+    try {
+        binary = atob(base64);
+    }
+    catch {
+        throw new Error("Harness source file is not valid base64.");
+    }
+    if (btoa(binary) !== base64)
+        throw new Error("Harness source file is not canonical base64.");
+    return Uint8Array.from(binary, character => character.charCodeAt(0));
+}

package/dist/source-runtime.js

@@ -0,0 +1,125 @@
+import { z } from "zod";
+import { contentHash } from "./common.js";
+import { harnessSourcePackageFiles, validateHarnessSourcePackage } from "./source-package.js";
+export const HARNESS_SOURCE_READ_TOOL_NAME = "harness_read_file";
+const ReadInputSchema = z.object({
+    path: z.string().min(1).max(2_000),
+    offset: z.number().int().nonnegative().default(0),
+    length: z.number().int().positive().max(65_536).default(16_384),
+}).strict();
+export const HARNESS_SOURCE_READ_TOOL = {
+    type: "function",
+    function: {
+        name: HARNESS_SOURCE_READ_TOOL_NAME,
+        description: "Read a byte range from a policy-visible file in the selected immutable Harness release. Paths are relative to that release; private files are unavailable.",
+        parameters: {
+            type: "object", properties: {
+                path: { type: "string" }, offset: { type: "integer", minimum: 0 },
+                length: { type: "integer", minimum: 1, maximum: 65_536 },
+            }, required: ["path"], additionalProperties: false,
+        },
+    },
+};
+/** Compile released instructions and Skills into an admitted context. Resource
+ * reads use the captured package, never the current workspace or channel. */
+export function createHarnessSourceRuntime(input) {
+    const source = validateHarnessSourcePackage(input.sourcePackage, input.expectedRelease);
+    const files = harnessSourcePackageFiles(source);
+    const { agentSnapshot, harnessRelease } = source;
+    const text = (path) => {
+        const bytes = files.get(path);
+        if (!bytes)
+            throw new Error(`Released Harness source is missing: ${path}`);
+        try {
+            return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        }
+        catch {
+            throw new Error(`Released Harness instruction source is not UTF-8: ${path}`);
+        }
+    };
+    const program = z.object({ runtimeProtocol: z.literal("openpond.agent-runtime.v1") }).strict();
+    if (!program.safeParse(JSON.parse(text(harnessRelease.program.path))).success
+        || harnessRelease.metadata.runtimeProtocol !== "openpond.agent-runtime.v1") {
+        throw new Error("Released Harness program requires a different execution adapter.");
+    }
+    if (agentSnapshot.agents.length)
+        throw new Error("This Harness runtime does not execute released subagent programs.");
+    const lock = z.object({ dependencies: z.record(z.string(), z.string()) }).strict()
+        .parse(JSON.parse(text(agentSnapshot.dependencyLock.path)));
+    for (const [name, version] of Object.entries(lock.dependencies)) {
+        if (input.dependencies?.[name] !== version)
+            throw new Error(`Released Harness dependency is unavailable: ${name}@${version}`);
+    }
+    const omittedCapabilities = [];
+    for (const requirement of agentSnapshot.capabilityRequirements) {
+        const available = input.capabilities?.find(capability => capability.id === requirement.id);
+        if (available && requirement.scopes.every(scope => available.scopes.includes(scope)))
+            continue;
+        if (requirement.required)
+            throw new Error(`Released Harness capability is unavailable: ${requirement.id}`);
+        omittedCapabilities.push(requirement.id);
+    }
+    if (input.tools.some(tool => tool.name === HARNESS_SOURCE_READ_TOOL_NAME))
+        throw new Error("Harness source reader conflicts with a runtime tool.");
+    for (const declared of [...agentSnapshot.toolDeclarations, ...harnessRelease.tools]) {
+        const available = input.tools.find(tool => tool.name === declared.name);
+        if (!available || contentHash(available.inputSchema) !== declared.inputSchemaHash
+            || contentHash(declared.inputSchema) !== declared.inputSchemaHash) {
+            throw new Error(`Released Harness tool is unavailable or has a different schema: ${declared.name}`);
+        }
+    }
+    const policyFiles = harnessRelease.files.filter(asset => asset.visibility === "policy"
+        && asset.path !== harnessRelease.program.path && asset.path !== agentSnapshot.dependencyLock.path);
+    const instructionSections = agentSnapshot.instructions.map(asset => `Released instruction (${asset.path}):\n${text(asset.path)}`);
+    const skillSections = agentSnapshot.skills.map(asset => `Released Skill (${asset.path}):\n${text(asset.path)}`);
+    const systemPrompt = [input.baseSystemPrompt,
+        ...instructionSections,
+        skillSections.length ? "Apply the following released Skills when relevant to the task. Read their referenced resources from the selected release with harness_read_file." : "",
+        ...skillSections,
+        policyFiles.length ? `Selected Harness files (paths relative to the release):\n${policyFiles.map(asset => asset.path).join("\n")}` : "",
+    ].filter(Boolean).join("\n\n");
+    if (!Number.isSafeInteger(input.maxContextCharacters) || input.maxContextCharacters <= 0
+        || systemPrompt.length > input.maxContextCharacters)
+        throw new Error("Released Harness context exceeds the runtime's admitted context limit.");
+    const readerFiles = new Map(policyFiles.map(asset => [asset.path, asset]));
+    const tools = policyFiles.length ? [HARNESS_SOURCE_READ_TOOL] : [];
+    const receipt = {
+        schemaVersion: "openpond.harnessSourceRuntimeReceipt.v1",
+        runtimeId: input.runtimeId,
+        harnessRelease: { id: harnessRelease.id, contentHash: harnessRelease.contentHash },
+        sourcePackageHash: source.contentHash,
+        systemPromptHash: contentHash(systemPrompt),
+        instructionAssets: agentSnapshot.instructions.map(asset => ({ path: asset.path, contentHash: asset.contentHash })),
+        skillAssets: agentSnapshot.skills.map(asset => ({ path: asset.path, contentHash: asset.contentHash })),
+        readableAssets: policyFiles.map(asset => ({ path: asset.path, contentHash: asset.contentHash })),
+        toolContractHash: contentHash([...input.tools.map(tool => tool.definition), ...tools]),
+        omittedCapabilities,
+    };
+    return {
+        systemPrompt,
+        tools,
+        receipt: { ...receipt, contentHash: contentHash(receipt) },
+        readFile(value) {
+            const request = ReadInputSchema.parse(value);
+            const asset = readerFiles.get(request.path);
+            if (!asset)
+                throw new Error("Harness source file is not policy-visible in the selected release.");
+            const bytes = files.get(request.path);
+            if (request.offset > bytes.length)
+                throw new Error("Harness source read offset exceeds the file size.");
+            const end = Math.min(bytes.length, request.offset + request.length);
+            const chunk = bytes.subarray(request.offset, end);
+            let content;
+            let encoding = "utf8";
+            try {
+                content = new TextDecoder("utf-8", { fatal: true }).decode(chunk);
+            }
+            catch {
+                encoding = "base64";
+                content = btoa(Array.from(chunk, byte => String.fromCharCode(byte)).join(""));
+            }
+            return { path: asset.path, contentHash: asset.contentHash, mediaType: asset.mediaType,
+                sizeBytes: asset.sizeBytes, offset: request.offset, nextOffset: end, eof: end === bytes.length, encoding, content };
+        },
+    };
+}

package/dist/types/index.d.ts

@@ -10,4 +10,8 @@ export * from "./refiner-detection.js";
 export * from "./refinement-lifecycle.js";
 export * from "./refiner-support.js";
 export * from "./tools.js";
+export * from "./source-package.js";
+export * from "./source-runtime.js";
+export * from "./provider-loop.js";
+export * from "./source-execution.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC"}

package/dist/types/provider-loop.d.ts

@@ -0,0 +1,53 @@
+export type ProviderRoundContext = {
+    index: number;
+    requestId: string;
+    signal: AbortSignal;
+};
+export type ProviderRoundDecision<TResult> = {
+    type: "continue";
+} | {
+    type: "complete";
+    result: TResult;
+};
+export type ProviderStreamDelta<TToolCall = unknown, TContinuation = unknown> = {
+    text?: string;
+    reasoningText?: string;
+    usage?: unknown;
+    continuation?: TContinuation;
+    toolCalls?: readonly TToolCall[];
+    finishReason?: string | null;
+};
+export type ProviderRoundResult<TToolCall = unknown, TContinuation = unknown> = {
+    text: string;
+    reasoningText: string;
+    usage: unknown;
+    continuation: TContinuation | null;
+    toolCallBatches: TToolCall[][];
+    finishReason: string | null | undefined;
+};
+export declare function providerRoundSequence(input: {
+    turnId: string;
+    maxRounds: number;
+    signal: AbortSignal;
+}): AsyncGenerator<ProviderRoundContext, void, unknown>;
+/** Owns provider/tool round sequencing, completion, exhaustion, and aborts. */
+export declare function runProviderRoundLoop<TResult>(input: {
+    turnId: string;
+    maxRounds: number;
+    signal: AbortSignal;
+    runRound(round: ProviderRoundContext): Promise<ProviderRoundDecision<TResult>>;
+    onExhausted(): Promise<TResult>;
+}): Promise<TResult>;
+/**
+ * Owns provider stream consumption and the normalized round result. The host
+ * supplies the provider request, usage recorder, and provider-specific delta
+ * shapes without duplicating the stream lifecycle.
+ */
+export declare function runProviderRound<TToolCall = unknown, TContinuation = unknown>(input: {
+    stream: AsyncIterable<ProviderStreamDelta<TToolCall, TContinuation>>;
+    signal: AbortSignal;
+    onDelta?(delta: ProviderStreamDelta<TToolCall, TContinuation>): void | Promise<void>;
+    onCompleted?(result: ProviderRoundResult<TToolCall, TContinuation>): Promise<void>;
+    onFailed?(error: unknown): Promise<void>;
+}): Promise<ProviderRoundResult<TToolCall, TContinuation>>;
+//# sourceMappingURL=provider-loop.d.ts.map

package/dist/types/provider-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-loop.d.ts","sourceRoot":"","sources":["../../../../src/provider-loop.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,OAAO,IACrC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC;AAE1C,MAAM,MAAM,mBAAmB,CAAC,SAAS,GAAG,OAAO,EAAE,aAAa,GAAG,OAAO,IAAI;IAC9E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,CAAC,SAAS,GAAG,OAAO,EAAE,aAAa,GAAG,OAAO,IAAI;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,EAAE,aAAa,GAAG,IAAI,CAAC;IACnC,eAAe,EAAE,SAAS,EAAE,EAAE,CAAC;IAC/B,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,wBAAuB,qBAAqB,CAAC,KAAK,EAAE;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;CACrB,GAAG,cAAc,CAAC,oBAAoB,EAAE,IAAI,EAAE,OAAO,CAAC,CAYtD;AAED,+EAA+E;AAC/E,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,KAAK,EAAE;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/E,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CACjC,GAAG,OAAO,CAAC,OAAO,CAAC,CAMnB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,SAAS,GAAG,OAAO,EACnB,aAAa,GAAG,OAAO,EACvB,KAAK,EAAE;IACP,MAAM,EAAE,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC;IACrE,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,CAAC,CAAC,KAAK,EAAE,mBAAmB,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,WAAW,CAAC,CAAC,MAAM,EAAE,mBAAmB,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnF,QAAQ,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C,GAAG,OAAO,CAAC,mBAAmB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,CAmCzD"}

package/dist/types/runtime-source.d.ts

@@ -0,0 +1,2 @@
+export declare const harnessRuntimeModuleSource: string;
+export declare const harnessRuntimeModuleSha256: string;

package/dist/types/source-execution.d.ts

@@ -0,0 +1,85 @@
+import { type createHarnessSourceRuntime } from "./source-runtime.js";
+export type HarnessPolicyMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null;
+    tool_call_id?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+};
+export type HarnessPolicyToolCall = {
+    id: string;
+    name: string;
+    arguments: string;
+};
+export type HarnessEnvironmentStep = {
+    toolResults: Array<{
+        id: string;
+        name: string;
+        output: unknown;
+    }>;
+    userMessage: string | null;
+    terminal: boolean;
+};
+/** Shared rollout lifecycle. Hosts own model transport, environment effects and
+ * grading; this runtime owns released resource calls and conversation history. */
+export declare function executeHarnessRollout<TPolicyResult, TStep extends HarnessEnvironmentStep>(input: {
+    turnId: string;
+    maxTurns: number;
+    signal: AbortSignal;
+    runtime: ReturnType<typeof createHarnessSourceRuntime> | null;
+    systemPrompt: string;
+    userPrompt: string;
+    tools: Array<Record<string, unknown>>;
+    policyRequest(request: {
+        turnIndex: number;
+        messages: HarnessPolicyMessage[];
+        tools: Array<Record<string, unknown>>;
+    }, signal: AbortSignal): Promise<{
+        result: TPolicyResult;
+        content: string | null;
+        toolCalls: HarnessPolicyToolCall[];
+    }>;
+    step(request: {
+        content: string | null;
+        toolCalls: HarnessPolicyToolCall[];
+    }, signal: AbortSignal): Promise<TStep>;
+    terminate(reason: "max_turns", signal: AbortSignal): Promise<TStep>;
+}): Promise<{
+    messages: HarnessPolicyMessage[];
+    toolSequence: string[];
+    trace: Record<string, unknown>[];
+    policyResults: TPolicyResult[];
+    finalStep: TStep;
+    runtimeReceipt: {
+        contentHash: string;
+        schemaVersion: "openpond.harnessSourceRuntimeReceipt.v1";
+        runtimeId: string;
+        harnessRelease: {
+            id: string;
+            contentHash: string;
+        };
+        sourcePackageHash: string;
+        systemPromptHash: string;
+        instructionAssets: {
+            path: string;
+            contentHash: string;
+        }[];
+        skillAssets: {
+            path: string;
+            contentHash: string;
+        }[];
+        readableAssets: {
+            path: string;
+            contentHash: string;
+        }[];
+        toolContractHash: string;
+        omittedCapabilities: string[];
+    } | null;
+}>;
+//# sourceMappingURL=source-execution.d.ts.map

package/dist/types/source-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-execution.d.ts","sourceRoot":"","sources":["../../../../src/source-execution.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAErG,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC,CAAC;CACrG,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AACpF,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAClE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;kFACkF;AAClF,wBAAsB,qBAAqB,CAAC,aAAa,EAAE,KAAK,SAAS,sBAAsB,EAAE,KAAK,EAAE;IACtG,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,GAAG,IAAI,CAAC;IAC9D,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACtC,aAAa,CAAC,OAAO,EAAE;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,oBAAoB,EAAE,CAAC;QACjC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;KACvC,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;QAC/B,MAAM,EAAE,aAAa,CAAC;QACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,SAAS,EAAE,qBAAqB,EAAE,CAAC;KACpC,CAAC,CAAC;IACH,IAAI,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,SAAS,EAAE,qBAAqB,EAAE,CAAA;KAAE,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACnH,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CACrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDA"}