@openpond/harness 0.2.5 → 0.3.0

package/CONTRACT.md

@@ -51,3 +51,38 @@ unselected evidence remains available to a later host watermark.
 Evaluation execution and model-improvement qualification contracts that bind a
 Harness to a Taskset, scored baseline, Model, verifier, and training signal
 belong to `@openpond/evals`.
+
+## Released source transport
+
+`openpond.harnessSourcePackage.v1` carries the complete immutable Agent
+snapshot, Harness release and their released file bytes. Creation and readback
+verify both release hashes, dependency references, the exact file population,
+canonical base64, individual file hashes and a 25 MiB total byte limit.
+Rehashing a transport envelope does not authorize different source bytes.
+Instruction and Skill entry files must be policy-visible; verifier and
+host-private assets retain their declared visibility and must never be exposed
+to a policy by iterating the complete source map.
+
+This is source transport, not runtime conformance. Hosts authorize export and
+select an execution adapter that consumes the captured source, verifies its
+capabilities and records effective context. A matching Harness release hash
+alone does not prove that instructions, Skills or executable dependencies ran.
+
+`createHarnessSourceRuntime` consumes captured source for the declarative
+`openpond.agent-runtime.v1` program. It loads released instruction and Skill
+text, verifies required capabilities, dependency versions and actual tool
+schemas, and exposes policy-visible resources through bounded byte-range reads.
+Private assets never enter its context or reader. Unsupported programs and
+released subagents fail admission. Hosts must provide their actual tools and
+capabilities; this helper does not implement missing execution capabilities.
+The runtime receipt binds the source, effective system prompt, loaded assets
+and tool definitions. Hosts retain that receipt with attempt evidence.
+
+`executeHarnessRollout` owns the shared policy/environment round lifecycle,
+released resource calls, retained conversation and exhaustion behavior. Hosts
+supply policy transport and environment step/termination operations. Desktop's
+agent runtime re-exports the same provider loop from this package.
+`@openpond/harness/runtime-source` distributes a self-contained ESM build of
+source admission and rollout execution with its SHA-256. Hosted archives use
+those published bytes instead of implementing a second source reader or loop.
+The clean consumer check executes this distribution without module resolution.

package/dist/common.js

@@ -10,6 +10,9 @@ export const ImmutableReleaseRefSchema = z.object({
     id: ReleaseIdSchema,
     contentHash: ReleaseHashSchema,
 }).strict();
+export const VersionedReleaseRefSchema = ImmutableReleaseRefSchema.extend({
+    revision: z.number().int().positive(),
+}).strict();
 export const ImmutableAssetRefSchema = z.object({
     id: ReleaseIdSchema,
     path: z.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),

package/dist/index.js

@@ -10,3 +10,7 @@ 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";

package/dist/models.js

@@ -8,3 +8,23 @@ export const ModelRefSchema = z.object({
     tokenizerRevision: z.string().trim().min(1).max(500).nullable().default(null),
     chatTemplateHash: ReleaseHashSchema.nullable().default(null),
 }).strict();
+export const PROVIDER_IDS = [
+    "openpond",
+    "codex",
+    "anthropic",
+    "openai",
+    "xai",
+    "google",
+    "openrouter",
+    "deepseek",
+    "zai",
+    "moonshot",
+    "together",
+    "groq",
+    "custom-openai-compatible",
+];
+export const ProviderIdSchema = z.enum(PROVIDER_IDS);
+export const ChatModelRefSchema = z.object({
+    providerId: ProviderIdSchema,
+    modelId: z.string().trim().min(1).max(300),
+});

package/dist/provider-loop.js

@@ -0,0 +1,70 @@
+export async function* providerRoundSequence(input) {
+    if (!Number.isInteger(input.maxRounds) || input.maxRounds < 1) {
+        throw new Error("Provider maxRounds must be a positive integer.");
+    }
+    for (let index = 0; index < input.maxRounds; index += 1) {
+        if (input.signal.aborted)
+            throw input.signal.reason ?? new Error("Provider loop interrupted.");
+        yield {
+            index,
+            requestId: `${input.turnId}:model:${index}`,
+            signal: input.signal
+        };
+    }
+}
+/** Owns provider/tool round sequencing, completion, exhaustion, and aborts. */
+export async function runProviderRoundLoop(input) {
+    for await (const round of providerRoundSequence(input)) {
+        const decision = await input.runRound(round);
+        if (decision.type === "complete")
+            return decision.result;
+    }
+    return input.onExhausted();
+}
+/**
+ * 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 async function runProviderRound(input) {
+    let text = "";
+    let reasoningText = "";
+    let usage;
+    let continuation = null;
+    let finishReason;
+    const toolCallBatches = [];
+    try {
+        for await (const delta of input.stream) {
+            await input.onDelta?.(delta);
+            if (input.signal.aborted) {
+                throw input.signal.reason ?? new Error("Provider round interrupted.");
+            }
+            if (delta.text)
+                text += delta.text;
+            if (delta.reasoningText)
+                reasoningText += delta.reasoningText;
+            if (delta.usage !== undefined)
+                usage = delta.usage;
+            if (delta.continuation !== undefined)
+                continuation = delta.continuation;
+            if (delta.toolCalls)
+                toolCallBatches.push([...delta.toolCalls]);
+            if (delta.finishReason !== undefined)
+                finishReason = delta.finishReason;
+        }
+        const result = {
+            text,
+            reasoningText,
+            usage,
+            continuation,
+            toolCallBatches,
+            finishReason,
+        };
+        await input.onCompleted?.(result);
+        return result;
+    }
+    catch (error) {
+        await input.onFailed?.(error);
+        throw error;
+    }
+}