@tangle-network/agent-runtime 0.94.10 → 0.94.12

package/dist/{agentic-generator-1g7GDba7.d.ts → agentic-generator-DDMM45kZ.d.ts}

@@ -1,6 +1,6 @@
-import { AnalystFinding, CostLedger, MaximumCharge } from '@tangle-network/agent-eval';
+import { AnalystFinding, CostLedgerHandle, MaximumCharge } from '@tangle-network/agent-eval';
 import { AgentProfile, ReasoningEffort } from '@tangle-network/agent-interface';
-import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionEvidence, r as runLocalHarness } from './local-harness-ZLMkKdZc.js';
+import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionEvidence, b as LocalHarnessResult, r as runLocalHarness } from './local-harness-ZqCx51u7.js';
 import { LabeledScenarioStore, WorktreeAdapter, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
 
 /**
@@ -59,7 +59,7 @@ interface CandidateGenerator {
         generation?: number;
         candidateIndex?: number;
         /** Shared run-wide paid-call account supplied by agent-eval 0.117+. */
-        costLedger?: CostLedger;
+        costLedger?: CostLedgerHandle;
         /** Receipt attribution phase supplied alongside `costLedger`. */
         costPhase?: string;
     }): Promise<{
@@ -166,6 +166,41 @@ interface AgenticGeneratorShotReceipt {
         readonly message: string;
     } | null;
 }
+/** Frozen exact harness result for an author shot: full streams, process state,
+ *  token usage, and execution-policy evidence.
+ *  The `onShotCompleted` callback receives `null` when execution failed before
+ *  the harness returned. */
+type AgenticGeneratorShotExecution = Readonly<Omit<LocalHarnessResult, 'usage' | 'evidence'> & {
+    readonly usage?: Readonly<CodexTokenUsage>;
+    readonly evidence?: Readonly<Omit<CodexExecutionEvidence, 'readDeniedPaths' | 'policy'>> & {
+        readonly readDeniedPaths: ReadonlyArray<string>;
+        readonly policy: Readonly<CodexExecutionEvidence['policy']>;
+    };
+}>;
+/** Worktree decision emitted before a completed shot is retried, accepted, or
+ *  discarded. The callback runs while `worktreePath` is still available, so
+ *  callers can persist the exact diff. */
+type AgenticGeneratorShotDisposition = {
+    readonly kind: 'clean';
+    readonly worktreePath: string;
+} | {
+    readonly kind: 'rejected';
+    readonly worktreePath: string;
+    readonly stage: 'raw-trace-evidence' | 'verification';
+    readonly feedback: string | null;
+} | {
+    readonly kind: 'accepted';
+    readonly worktreePath: string;
+    readonly verified: boolean;
+} | {
+    readonly kind: 'setup-error';
+    readonly worktreePath: string;
+    readonly stage: 'worktree-inspection' | 'raw-trace-evidence' | 'verification';
+    readonly error: {
+        readonly name: string;
+        readonly message: string;
+    };
+};
 interface AgenticGeneratorOptions {
     /** Local coding harness to run in the worktree. Default `claude`. */
     harness?: LocalHarness;
@@ -179,8 +214,13 @@ interface AgenticGeneratorOptions {
      *  candidate-specific paths after the driver creates its worktree. */
     codexReadDeniedPaths?: ReadonlyArray<string> | ((worktreePath: string) => ReadonlyArray<string>);
     /** Awaited once for every attempted author shot, including process failures.
-     *  Throwing aborts the candidate so receipt persistence can fail closed. */
-    onShotCompleted?: (receipt: AgenticGeneratorShotReceipt) => void | Promise<void>;
+     *  The second argument preserves the exact harness result, including stdout
+     *  and stderr, before worktree inspection or verification can reject the
+     *  shot. Throwing aborts the candidate so evidence persistence fails closed. */
+    onShotCompleted?: (receipt: AgenticGeneratorShotReceipt, execution: AgenticGeneratorShotExecution | null) => void | Promise<void>;
+    /** Awaited after worktree inspection and before the shot is accepted,
+     *  retried, or discarded. Throwing aborts the candidate. */
+    onShotDisposition?: (receipt: AgenticGeneratorShotReceipt, disposition: AgenticGeneratorShotDisposition) => void | Promise<void>;
     /** Optional hard upper bound passed to the run-wide CostLedger before each
      *  author shot. This MUST be enforced by the provider or executor; a planning
      *  estimate is not an admissible bound. Omit for an uncapped ledger. A capped
@@ -215,4 +255,4 @@ declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGene
  *  silent fallback). */
 declare function commandVerifier(command: string, args?: string[], timeoutMs?: number): Verifier;
 
-export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImprovementDriverOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type AgenticGeneratorOptions as a, type AgenticGeneratorShotReceipt as b, type VerifyResult as c, agenticGenerator as d, commandVerifier as e, improvementDriver as i };
+export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImprovementDriverOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type AgenticGeneratorOptions as a, type AgenticGeneratorShotDisposition as b, type AgenticGeneratorShotExecution as c, type AgenticGeneratorShotReceipt as d, type VerifyResult as e, agenticGenerator as f, commandVerifier as g, improvementDriver as i };

package/dist/analyst-loop.d.ts

@@ -1,8 +1,9 @@
 import { TraceAnalystByteBudgets, TraceAnalysisStore } from '@tangle-network/agent-eval';
-import { I as Iteration } from './types-CKmyZ9TP.js';
+import { I as Iteration } from './types-ByAYqlVb.js';
 import { R as RunAnalystLoopOpts, a as RunAnalystLoopResult } from './types-BC3bZpH0.js';
 export { A as AnalystLoopEvent, b as AnalystRegistryLike, c as AnalystRegistryStreamingLike, d as AutoApplyPolicy, F as FindingsStoreLike, I as ImprovementAdapter, e as ImprovementEditBatch, f as ImprovementReport, K as KnowledgeAdapter, g as KnowledgeProposalBatch, h as KnowledgeReport } from './types-BC3bZpH0.js';
 import '@tangle-network/sandbox';
+import './types-BwoZWq-i.js';
 
 /**
  *

package/dist/backends-BO4Jqoe2.d.ts

@@ -0,0 +1,134 @@
+import { A as AgentBackendInput, O as OpenAIChatTool, a as OpenAIChatToolChoice, b as OpenAIChatResponseFormat, c as AgentExecutionBackend, d as AgentBackendContext, R as RuntimeStreamEvent } from './types-BwoZWq-i.js';
+
+/**
+ *
+ * Backend factories for `runAgentTaskStream`. Three shapes ship in core:
+ *
+ *  - `createIterableBackend` — wrap any custom async iterable into a backend
+ *  - `createSandboxPromptBackend` — sandbox / sidecar `streamPrompt` clients
+ *  - `createOpenAICompatibleBackend` — OpenAI-style chat completions endpoints
+ *
+ * Adapters stay thin: domain repos own auth, model selection, and the concrete
+ * tool surface. The factories handle session creation, stream normalization,
+ * and graceful end-of-stream signalling.
+ *
+ * @stable
+ */
+
+/** Wrap any custom async-iterable stream into a typed `AgentExecutionBackend`. @stable */
+declare function createIterableBackend<TInput extends AgentBackendInput>(options: {
+    kind: string;
+    start?: AgentExecutionBackend<TInput>['start'];
+    resume?: AgentExecutionBackend<TInput>['resume'];
+    stream: AgentExecutionBackend<TInput>['stream'];
+    stop?: AgentExecutionBackend<TInput>['stop'];
+}): AgentExecutionBackend<TInput>;
+/** Build an `AgentExecutionBackend` backed by a sandbox/sidecar `streamPrompt` call. @stable */
+declare function createSandboxPromptBackend<TBox, TInput extends AgentBackendInput = AgentBackendInput>(options: {
+    kind?: string;
+    getBox(input: TInput, context: Omit<AgentBackendContext, 'session'>): Promise<TBox> | TBox;
+    streamPrompt(box: TBox, message: string, context: AgentBackendContext): AsyncIterable<unknown>;
+    mapEvent?: (event: unknown, context: AgentBackendContext) => RuntimeStreamEvent | undefined;
+    getSessionId?: (box: TBox, input: TInput) => string | undefined;
+}): AgentExecutionBackend<TInput>;
+/** @stable */
+/**
+ * Retry policy for transient transport errors (rate limits, upstream
+ * timeouts). Defaults to 5 attempts with exponential backoff starting at
+ * 1s, ±25% jitter, capped at 30s. Set `maxAttempts: 1` to disable retries.
+ *
+ * Retried status codes:
+ *   - 408 Request Timeout
+ *   - 425 Too Early
+ *   - 429 Too Many Requests
+ *   - 500 / 502 / 503 / 504 — upstream transient failures
+ *
+ * Hard failures (401, 403, 4xx other than the above) propagate immediately.
+ */
+interface BackendRetryPolicy {
+    /** Total attempts including the first try. Default 5. */
+    maxAttempts?: number;
+    /** Initial backoff in ms before the second attempt. Default 1000. */
+    initialBackoffMs?: number;
+    /** Hard ceiling on backoff in ms. Default 30000. */
+    maxBackoffMs?: number;
+    /** Jitter fraction in [0, 1]. Default 0.25 (±25%). */
+    jitter?: number;
+    /** Status codes that trigger a retry. Default: 408, 425, 429, 500, 502, 503, 504. */
+    retryStatuses?: ReadonlyArray<number>;
+    /**
+     * Per-attempt wall-clock deadline in ms. If a single fetch attempt does
+     * not return headers within this window the attempt is aborted and
+     * retried. Default 120000 (2 min). Without this a hung upstream blocks
+     * the attempt indefinitely — observed in production as a 15-minute
+     * `fetch failed` that burned an entire eval persona. Set to 0 to disable.
+     */
+    requestTimeoutMs?: number;
+}
+/**
+ *
+ * OpenAI-compat streaming backend. Routes `runAgentTaskStream` through any
+ * `POST /chat/completions` endpoint that speaks OpenAI's SSE protocol —
+ * Tangle Router, OpenAI direct, OpenRouter, Groq, DeepSeek, Together. The
+ * router also fronts Anthropic models in Anthropic-native SSE shape; this
+ * backend handles both.
+ *
+ * ### Tool calls
+ *
+ * Pass `tools` (and optionally `toolChoice`) to forward an OpenAI Chat
+ * Completions `tools[]` array on every request. Streamed `tool_call` chunks
+ * are buffered until the model finalizes them (either `finish_reason:
+ * 'tool_calls'` for OpenAI shape or a `content_block_stop` for Anthropic
+ * `tool_use` blocks proxied through the router), then emitted as a single
+ * `tool_call` RuntimeStreamEvent with the assembled `args`.
+ *
+ * The backend does NOT execute tools — it surfaces calls for the caller's
+ * own dispatcher (typically the product's MCP / sandbox runtime) to fulfill
+ * and feed back as a subsequent `messages` turn. This keeps the transport
+ * thin and lets the agent host own tool dispatch policy.
+ *
+ * ### Fail-loud errors
+ *
+ * Non-success HTTP responses (4xx/5xx) and exhausted retry budgets throw
+ * `BackendTransportError` from inside the `stream()` generator. The runtime
+ * catches the throw, yields a `backend_error` with a typed `error` field
+ * (`kind`, `status`, truncated `body`) and a terminal `final` event with
+ * `status: 'failed'` carrying the same detail. Consumers MUST map
+ * `final.error` onto their `RunRecord.error` — silently treating an empty
+ * `finalText` as "agent produced nothing" hides credit exhaustion, auth
+ * failure, and upstream outages.
+ *
+ * @stable
+ */
+declare function createOpenAICompatibleBackend<TInput extends AgentBackendInput = AgentBackendInput>(options: {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    kind?: string;
+    /**
+     * OpenAI Chat Completions `tools[]` definitions surfaced to the model on
+     * every request. Omit to send a tool-free request (existing behavior).
+     * The runtime makes no assumption about the dispatcher — calls stream out
+     * as `tool_call` events and the caller is responsible for executing them
+     * and feeding `tool_result` messages back on a follow-up turn.
+     */
+    tools?: ReadonlyArray<OpenAIChatTool>;
+    /**
+     * OpenAI Chat Completions `tool_choice`. Default `undefined` (request
+     * omits the field; provider falls back to its own default — typically
+     * `'auto'`).
+     */
+    toolChoice?: OpenAIChatToolChoice;
+    /**
+     * OpenAI Chat Completions `response_format`. Omit for provider default text.
+     */
+    responseFormat?: OpenAIChatResponseFormat;
+    /** OpenAI Chat Completions `temperature`. Omit for provider default. */
+    temperature?: number;
+    /** Maximum completion tokens, sent as OpenAI-compatible `max_tokens`. Omit for provider default. */
+    maxTokens?: number;
+    fetchImpl?: typeof fetch;
+    retry?: BackendRetryPolicy;
+}): AgentExecutionBackend<TInput>;
+
+export { createIterableBackend as a, createSandboxPromptBackend as b, createOpenAICompatibleBackend as c };