openpond 0.0.38 → 0.0.39

package/dist/chunks/chunk-VCVQLECH.js

@@ -0,0 +1,675 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  external_exports
+} from "./chunk-WYDVQOBL.js";
+
+// ../../packages/agent-runtime/dist/compaction.js
+function agentCompactionDecision(input) {
+  if (!input.maxContextTokens || !input.usableContextTokens) {
+    return {
+      shouldCompact: false,
+      projectedTokens: input.projectedTokens,
+      thresholdTokens: Number.MAX_SAFE_INTEGER,
+      usableContextTokens: 0,
+      maxContextTokens: 0,
+      tokenSource: "heuristic"
+    };
+  }
+  const triggerRatio = Math.max(0.01, Math.min(1, (input.triggerPercent ?? 85) / 100));
+  const thresholdTokens = Math.max(1, Math.floor(input.usableContextTokens * triggerRatio));
+  return {
+    shouldCompact: input.projectedTokens >= thresholdTokens,
+    projectedTokens: input.projectedTokens,
+    thresholdTokens,
+    usableContextTokens: input.usableContextTokens,
+    maxContextTokens: input.maxContextTokens,
+    tokenSource: "heuristic"
+  };
+}
+async function runAgentCompaction(host) {
+  await host.started();
+  try {
+    return await host.compact();
+  } catch (error) {
+    await host.failed(error);
+    throw error;
+  }
+}
+async function runAgentCompactionProgram(input) {
+  const projectionEvents = input.host.projectEvents(input.events);
+  const selection = input.host.selectEvents(projectionEvents, input.maxContextTokens);
+  const { summaryEvents, preservedEvents, preservedEventIds } = selection;
+  if (summaryEvents.length === 0) {
+    throw new Error("There is not enough prior context to compact.");
+  }
+  const summaryRecords = input.host.normalizeRecords(summaryEvents);
+  const fileLedger = input.host.buildFileLedger(input.host.normalizeRecords(projectionEvents));
+  const serialized = input.host.serializeRecords(summaryRecords, input.host.inputCharBudget(input.maxContextTokens));
+  if (!serialized.text.trim()) {
+    throw new Error("There is not enough prior context to compact.");
+  }
+  const messages = input.host.buildSummaryMessages({
+    serializedHistory: serialized.text,
+    fileLedger
+  });
+  const startedAtMs = Date.now();
+  const summary = (await input.host.streamSummary({
+    model: input.model,
+    messages,
+    signal: input.signal
+  })).trim();
+  const durationMs = Date.now() - startedAtMs;
+  if (!summary)
+    throw new Error("Compaction summary was empty.");
+  const projection = input.host.estimateProjection({
+    events: projectionEvents,
+    preservedEvents,
+    summary
+  });
+  const metrics = input.host.createMetrics({
+    sourceEvents: projectionEvents.length,
+    summarizedEvents: summaryEvents.length,
+    preservedEvents: preservedEvents.length,
+    summaryInputChars: serialized.inputChars,
+    retainedTailTokens: selection.retainedTailTokens,
+    retainedTailBudgetTokens: selection.retainedTailBudgetTokens,
+    finalProviderContextTokens: projection.inputTokensAfter,
+    durationMs,
+    fileLedgerEntries: fileLedger.length,
+    splitTurnId: selection.splitTurnId
+  });
+  return {
+    summary,
+    model: input.model,
+    compactedThroughEventId: projectionEvents[projectionEvents.length - 1]?.id ?? null,
+    compactedThroughTurnId: input.host.lastTurnId(projectionEvents),
+    preservedFromEventId: preservedEvents[0]?.id ?? null,
+    preservedEventIds,
+    preservedResourceRefs: input.host.durableResourceRefs(input.events),
+    sourceEventCount: summaryEvents.length,
+    preservedEventCount: preservedEvents.length,
+    fileLedger,
+    inputTokensBefore: projection.inputTokensBefore,
+    inputTokensAfter: projection.inputTokensAfter,
+    maxContextTokens: input.maxContextTokens,
+    tokenSource: "heuristic",
+    metrics
+  };
+}
+
+// ../../packages/agent-runtime/dist/canonical.js
+import { createHash } from "node:crypto";
+function canonicalJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new Error("Canonical JSON cannot encode a non-finite number.");
+    return value;
+  }
+  if (Array.isArray(value))
+    return value.map(canonicalJson);
+  if (typeof value === "object") {
+    const output = {};
+    for (const key of Object.keys(value).sort()) {
+      const member = value[key];
+      if (member !== void 0)
+        output[key] = canonicalJson(member);
+    }
+    return output;
+  }
+  throw new Error(`Canonical JSON cannot encode ${typeof value}.`);
+}
+function canonicalHash(value) {
+  return createHash("sha256").update(JSON.stringify(canonicalJson(value)), "utf8").digest("hex");
+}
+
+// ../../packages/agent-runtime/dist/events.js
+var AgentEventNameSchema = external_exports.enum([
+  "thread.started",
+  "thread.resumed",
+  "turn.started",
+  "turn.steered",
+  "turn.interrupted",
+  "turn.completed",
+  "turn.failed",
+  "item.started",
+  "item.delta",
+  "item.completed",
+  "assistant.reasoning.delta",
+  "assistant.delta",
+  "tool.started",
+  "tool.completed",
+  "approval.requested",
+  "approval.resolved",
+  "user_input.requested",
+  "user_input.resolved",
+  "compaction.started",
+  "compaction.completed",
+  "harness.admitted",
+  "harness.refiner.queued",
+  "harness.refiner.started",
+  "harness.refiner.completed",
+  "harness.refiner.failed",
+  "diagnostic"
+]);
+var CanonicalAgentEventSchema = external_exports.object({
+  sequence: external_exports.number().int().nonnegative(),
+  name: AgentEventNameSchema,
+  source: external_exports.enum(["runtime", "provider", "tool", "host", "refiner"]),
+  status: external_exports.string().trim().min(1).nullable().default(null),
+  threadId: external_exports.string().trim().min(1),
+  turnId: external_exports.string().trim().min(1).nullable().default(null),
+  callId: external_exports.string().trim().min(1).nullable().default(null),
+  output: external_exports.string().nullable().default(null),
+  error: external_exports.string().nullable().default(null),
+  data: external_exports.record(external_exports.string(), external_exports.unknown()).default({})
+}).strict();
+function canonicalEventHash(event) {
+  return canonicalHash(CanonicalAgentEventSchema.parse(event));
+}
+
+// ../../packages/agent-runtime/dist/protocol.js
+var AGENT_PROTOCOL_VERSION = "2026-08-06";
+var AGENT_RPC_METHODS = [
+  "initialize",
+  "initialized",
+  "runtime/capabilities",
+  "thread/start",
+  "thread/resume",
+  "thread/read",
+  "turn/start",
+  "turn/steer",
+  "turn/interrupt",
+  "approval/resolve",
+  "userInput/resolve",
+  "harness/inspect",
+  "harness/validate"
+];
+var JsonRpcRequestSchema = external_exports.object({
+  jsonrpc: external_exports.literal("2.0"),
+  id: external_exports.union([external_exports.string(), external_exports.number()]),
+  method: external_exports.string().trim().min(1),
+  params: external_exports.unknown().optional()
+}).strict();
+var JsonRpcNotificationSchema = external_exports.object({
+  jsonrpc: external_exports.literal("2.0"),
+  method: external_exports.string().trim().min(1),
+  params: external_exports.unknown().optional()
+}).strict();
+var JsonRpcSuccessSchema = external_exports.object({
+  jsonrpc: external_exports.literal("2.0"),
+  id: external_exports.union([external_exports.string(), external_exports.number()]),
+  result: external_exports.unknown()
+}).strict();
+var JsonRpcErrorSchema = external_exports.object({
+  jsonrpc: external_exports.literal("2.0"),
+  id: external_exports.union([external_exports.string(), external_exports.number(), external_exports.null()]),
+  error: external_exports.object({
+    code: external_exports.number().int(),
+    message: external_exports.string(),
+    data: external_exports.unknown().optional()
+  }).strict()
+}).strict();
+var AgentProtocolEnvelopeSchema = external_exports.union([
+  JsonRpcRequestSchema,
+  JsonRpcNotificationSchema,
+  JsonRpcSuccessSchema,
+  JsonRpcErrorSchema
+]);
+var InitializeParamsSchema = external_exports.object({
+  protocolVersion: external_exports.string().trim().min(1),
+  client: external_exports.object({
+    name: external_exports.string().trim().min(1),
+    version: external_exports.string().trim().min(1)
+  }).strict(),
+  capabilities: external_exports.record(external_exports.string(), external_exports.unknown()).default({})
+}).strict();
+var AgentJsonRpcDispatcher = class {
+  #host;
+  #initializeParams = null;
+  #initialized = false;
+  constructor(host) {
+    this.#host = host;
+  }
+  get initialized() {
+    return this.#initialized;
+  }
+  async handle(value) {
+    const notification = JsonRpcNotificationSchema.safeParse(value);
+    if (notification.success && !("id" in value)) {
+      if (notification.data.method === "initialized") {
+        if (!this.#initializeParams)
+          throw new JsonRpcDispatchError(-32002, "initialize must be called first");
+        this.#initialized = true;
+      }
+      return null;
+    }
+    const parsed = JsonRpcRequestSchema.safeParse(value);
+    if (!parsed.success)
+      return jsonRpcError(null, -32600, "Invalid Request", parsed.error.flatten());
+    const request = parsed.data;
+    try {
+      const result = await this.#dispatch(request.method, request.params);
+      return { jsonrpc: "2.0", id: request.id, result };
+    } catch (error) {
+      const dispatchError = error instanceof JsonRpcDispatchError ? error : new JsonRpcDispatchError(-32603, error instanceof Error ? error.message : String(error));
+      return jsonRpcError(request.id, dispatchError.code, dispatchError.message, dispatchError.data);
+    }
+  }
+  async #dispatch(method, params) {
+    if (method === "initialize") {
+      const input = InitializeParamsSchema.parse(params);
+      if (input.protocolVersion !== AGENT_PROTOCOL_VERSION) {
+        throw new JsonRpcDispatchError(-32001, "Incompatible agent protocol version", {
+          requested: input.protocolVersion,
+          supported: AGENT_PROTOCOL_VERSION
+        });
+      }
+      this.#initializeParams = input;
+      return {
+        protocolVersion: AGENT_PROTOCOL_VERSION,
+        server: { name: "openpond-app-server", version: "1" },
+        capabilities: await this.#host.capabilities()
+      };
+    }
+    if (!this.#initialized)
+      throw new JsonRpcDispatchError(-32002, "initialized notification is required");
+    switch (method) {
+      case "runtime/capabilities":
+        return this.#host.capabilities(params);
+      case "thread/start":
+        return this.#host.threadStart(params);
+      case "thread/resume":
+        return this.#host.threadResume(params);
+      case "thread/read":
+        return this.#host.threadRead(params);
+      case "turn/start":
+        return this.#host.turnStart(params);
+      case "turn/steer":
+        return this.#host.turnSteer(params);
+      case "turn/interrupt":
+        return this.#host.turnInterrupt(params);
+      case "approval/resolve":
+        return this.#host.approvalResolve(params);
+      case "userInput/resolve":
+        return this.#host.userInputResolve(params);
+      case "harness/inspect":
+        return this.#host.harnessInspect(params);
+      case "harness/validate":
+        return this.#host.harnessValidate(params);
+      default:
+        throw new JsonRpcDispatchError(-32601, `Method not found: ${method}`);
+    }
+  }
+};
+var JsonRpcDispatchError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+};
+function jsonRpcError(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: { code, message, ...data === void 0 ? {} : { data } }
+  };
+}
+
+// ../../packages/agent-runtime/dist/jsonl.js
+import { once } from "node:events";
+import { createInterface } from "node:readline";
+async function runAgentJsonlServer(input) {
+  const dispatcher = new AgentJsonRpcDispatcher(input.host);
+  let writeChain = Promise.resolve();
+  const pendingNotifications = [];
+  const write = (message) => {
+    writeChain = writeChain.then(async () => {
+      if (!input.writable.write(`${JSON.stringify(message)}
+`))
+        await once(input.writable, "drain");
+    });
+    return writeChain;
+  };
+  const flushPendingNotifications = () => {
+    if (!dispatcher.initialized || pendingNotifications.length === 0)
+      return;
+    for (const notification of pendingNotifications.splice(0))
+      void write(notification);
+  };
+  const unsubscribe = input.host.subscribe?.((notification) => {
+    if (!dispatcher.initialized) {
+      pendingNotifications.push(notification);
+      return;
+    }
+    void write(notification);
+  });
+  const inFlight = /* @__PURE__ */ new Set();
+  const lines = createInterface({ input: input.readable, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      if (!line.trim())
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        await write({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32700, message: "Parse error" }
+        });
+        continue;
+      }
+      const operation = (async () => {
+        const response = await dispatcher.handle(parsed);
+        if (response)
+          await write(response);
+        flushPendingNotifications();
+      })();
+      const method = parsed && typeof parsed === "object" && "method" in parsed ? parsed.method : null;
+      if (method === "initialize" || method === "initialized") {
+        await operation;
+        continue;
+      }
+      inFlight.add(operation);
+      void operation.finally(() => inFlight.delete(operation));
+    }
+    await Promise.all(inFlight);
+    await writeChain;
+  } finally {
+    unsubscribe?.();
+  }
+}
+
+// ../../packages/agent-runtime/dist/provider-loop.js
+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
+    };
+  }
+}
+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();
+}
+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) {
+      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 !== void 0)
+        usage = delta.usage;
+      if (delta.continuation !== void 0)
+        continuation = delta.continuation;
+      if (delta.toolCalls)
+        toolCallBatches.push([...delta.toolCalls]);
+      if (delta.finishReason !== void 0)
+        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;
+  }
+}
+
+// ../../packages/agent-runtime/dist/service.js
+var ThreadIdParamsSchema = external_exports.object({ threadId: external_exports.string().trim().min(1) }).passthrough();
+var ThreadStartParamsSchema = external_exports.object({ session: external_exports.unknown() }).strict();
+var TurnParamsSchema = ThreadIdParamsSchema.extend({ input: external_exports.unknown() });
+var InterruptParamsSchema = ThreadIdParamsSchema.extend({ reason: external_exports.string().trim().min(1).optional() });
+var ApprovalParamsSchema = external_exports.object({ approvalId: external_exports.string().trim().min(1), input: external_exports.unknown() }).strict();
+function createAgentRuntimeService(ports) {
+  const run = async (method, threadId, operation) => {
+    const startedAt = performance.now();
+    ports.telemetry?.({ method, phase: "started", threadId, durationMs: null, errorClass: null });
+    try {
+      const result = await operation();
+      ports.telemetry?.({
+        method,
+        phase: "completed",
+        threadId,
+        durationMs: performance.now() - startedAt,
+        errorClass: null
+      });
+      return result;
+    } catch (error) {
+      ports.telemetry?.({
+        method,
+        phase: "failed",
+        threadId,
+        durationMs: performance.now() - startedAt,
+        errorClass: error instanceof Error ? error.name : "UnknownError"
+      });
+      throw error;
+    }
+  };
+  const threadRead = async (params, method = "thread/read") => {
+    const { threadId } = ThreadIdParamsSchema.parse(params);
+    return run(method, threadId, async () => {
+      const [thread, turns, events] = await Promise.all([
+        ports.readThread(threadId),
+        ports.listTurns(threadId),
+        ports.listEvents(threadId)
+      ]);
+      return { thread, turns, events };
+    });
+  };
+  return {
+    capabilities: (params) => run("runtime/capabilities", null, () => ports.capabilities(params)),
+    threadStart: async (params) => run("thread/start", null, async () => ({
+      thread: await ports.createThread(ThreadStartParamsSchema.parse(params).session)
+    })),
+    threadResume: (params) => threadRead(params, "thread/resume"),
+    threadRead,
+    turnStart: async (params) => {
+      const input = TurnParamsSchema.parse(params);
+      return run("turn/start", input.threadId, async () => ({
+        turn: await ports.startTurn(input.threadId, input.input)
+      }));
+    },
+    turnSteer: async (params) => {
+      const input = TurnParamsSchema.parse(params);
+      return run("turn/steer", input.threadId, async () => {
+        if (ports.isTurnActive(input.threadId)) {
+          await ports.waitForTurnSettlement(input.threadId);
+        }
+        return { turn: await ports.startTurn(input.threadId, input.input) };
+      });
+    },
+    turnInterrupt: async (params) => {
+      const input = InterruptParamsSchema.parse(params);
+      return run("turn/interrupt", input.threadId, async () => ({
+        turn: await ports.interruptTurn(input.threadId, input.reason)
+      }));
+    },
+    approvalResolve: async (params) => {
+      const input = ApprovalParamsSchema.parse(params);
+      return run("approval/resolve", null, async () => ({
+        approval: await ports.resolveApproval(input.approvalId, input.input)
+      }));
+    },
+    userInputResolve: async (params) => {
+      const input = TurnParamsSchema.parse(params);
+      return run("userInput/resolve", input.threadId, async () => {
+        if (ports.isTurnActive(input.threadId)) {
+          await ports.waitForTurnSettlement(input.threadId);
+        }
+        return { turn: await ports.startTurn(input.threadId, input.input) };
+      });
+    },
+    harnessInspect: () => run("harness/inspect", null, () => ports.inspectHarness()),
+    harnessValidate: () => run("harness/validate", null, () => ports.validateHarness()),
+    subscribe: ports.subscribeEvents && ports.eventNotification ? (listener) => ports.subscribeEvents((event) => listener(ports.eventNotification(event))) : void 0
+  };
+}
+
+// ../../packages/agent-runtime/dist/snapshots.js
+var HashSchema = external_exports.string().regex(/^[a-f0-9]{64}$/);
+var AgentEffectiveSurfaceSchema = external_exports.object({
+  harnessReleaseHash: HashSchema,
+  instructionsHash: HashSchema,
+  skillHashes: external_exports.record(external_exports.string(), HashSchema),
+  agentAssetHashes: external_exports.record(external_exports.string(), HashSchema),
+  toolCatalogHash: HashSchema,
+  memoryRevision: external_exports.number().int().nonnegative().nullable()
+}).strict();
+var AgentCheckpointSchema = external_exports.object({
+  protocolVersion: external_exports.string().trim().min(1),
+  threadId: external_exports.string().trim().min(1),
+  turnId: external_exports.string().trim().min(1),
+  harnessReleaseHash: HashSchema,
+  toolCatalogHash: HashSchema,
+  context: external_exports.record(external_exports.string(), external_exports.unknown()),
+  pendingInteraction: external_exports.record(external_exports.string(), external_exports.unknown()).nullable(),
+  usage: external_exports.record(external_exports.string(), external_exports.unknown())
+}).strict();
+function checkpointHash(checkpoint) {
+  return canonicalHash(AgentCheckpointSchema.parse(checkpoint));
+}
+function materializeAgentPrompt(input) {
+  return [
+    input.system,
+    ...input.harnessInstructions,
+    ...input.skillInstructions,
+    ...input.hostInstructions ?? []
+  ].map((part) => part.trim()).filter(Boolean).join("\n\n");
+}
+
+// ../../packages/agent-runtime/dist/tools.js
+function createAgentToolCatalogProjection(definitions) {
+  const names = /* @__PURE__ */ new Set();
+  const tools = [...definitions].map((definition) => {
+    const name = definition.name.trim();
+    if (!name)
+      throw new Error("Agent tool names cannot be empty.");
+    if (names.has(name))
+      throw new Error(`Duplicate agent tool: ${name}.`);
+    names.add(name);
+    if (!definition.unavailableReason && !definition.executorAvailable) {
+      throw new Error(`Agent tool ${name} is declared as available without an executor.`);
+    }
+    return { ...definition, name };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+  const modelTools = tools.filter((tool) => !tool.unavailableReason).map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  }));
+  const capabilities = tools.map((tool) => ({
+    name: tool.name,
+    displayLabel: tool.displayLabel ?? tool.name,
+    placement: tool.placement,
+    available: !tool.unavailableReason,
+    unavailableReason: tool.unavailableReason ?? null
+  }));
+  return {
+    byName: new Map(tools.map((tool) => [tool.name, tool])),
+    tools,
+    modelTools,
+    capabilities,
+    hash: canonicalHash({ modelTools, capabilities })
+  };
+}
+async function executeProjectedAgentTool(catalog, input) {
+  const definition = catalog.byName.get(input.name);
+  if (!definition)
+    throw new Error(`Unknown agent tool: ${input.name}.`);
+  if (definition.unavailableReason) {
+    throw new Error(`Agent tool ${input.name} is unavailable: ${definition.unavailableReason}`);
+  }
+  if (!definition.execute)
+    throw new Error(`Agent tool ${input.name} has no executor.`);
+  const validated = definition.validateArguments ? definition.validateArguments(input.arguments) : input.arguments;
+  return definition.execute(validated, input.context);
+}
+
+// ../../packages/app-server/dist/index.js
+function createAppServer(input) {
+  return attachAppServer({
+    runtime: createAgentRuntimeService(input.ports),
+    close: input.close
+  });
+}
+function attachAppServer(input) {
+  let closed = false;
+  return {
+    runtime: input.runtime,
+    close: async () => {
+      if (closed)
+        return;
+      closed = true;
+      await input.close?.();
+    }
+  };
+}
+async function runAppServerJsonl(input) {
+  try {
+    await runAgentJsonlServer({
+      host: input.appServer.runtime,
+      readable: input.readable,
+      writable: input.writable
+    });
+  } finally {
+    await input.appServer.close();
+  }
+}
+
+export {
+  canonicalHash,
+  agentCompactionDecision,
+  runAgentCompaction,
+  runAgentCompactionProgram,
+  CanonicalAgentEventSchema,
+  canonicalEventHash,
+  AGENT_PROTOCOL_VERSION,
+  AGENT_RPC_METHODS,
+  runProviderRoundLoop,
+  runProviderRound,
+  AgentCheckpointSchema,
+  checkpointHash,
+  materializeAgentPrompt,
+  createAgentToolCatalogProjection,
+  executeProjectedAgentTool,
+  createAppServer,
+  runAppServerJsonl
+};