@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/tenant/turn-timing.d.ts

@@ -13,6 +13,8 @@ export interface TurnTiming {
     turnStartedAt?: string;
     /** The trace context the turn's message arrived with (R7.4); it ends with the turn. */
     turnTrace?: unknown;
+    /** What started the turn when not a client (track T4); it ends with the turn. */
+    turnCause?: unknown;
     pausedMs?: number;
     pausedAt?: string;
 }
@@ -25,16 +27,24 @@ export declare function resumeTurn(s: TurnTiming, now?: Date): void;
 /**
  * The facts the event that ends turn `turnId` carries: `durationMs` from its start to now, waits
  * included, so the turn's span holds every crossing in it; `pausedMs`, how long it waited paused
- * (a wait still open ends now, as for a cancel); the session's agent;
+ * (a wait still open ends now, as for a cancel); the session's Agent and the manifest version it runs;
  * and the turn's totals from the usage ledger (one read, as `/v1/tenant/usage` totals a turn;
  * `steps` are the model calls the gate metered). Clears the turn's timing from `s`.
  */
 export declare function endTurn(t: Tx, s: TurnTiming & {
     agentId: string;
+    definition?: {
+        name: string;
+        version: number;
+    };
 }, turnId: string | null, now?: Date): Promise<{
     durationMs?: number;
     pausedMs?: number;
     agentId: string;
+    manifest?: {
+        name: string;
+        version: number;
+    };
     totals?: {
         steps: number;
         tokens: number;

package/dist/tenant/turn-timing.js

@@ -19,7 +19,7 @@ export function resumeTurn(s, now = new Date()) {
 /**
  * The facts the event that ends turn `turnId` carries: `durationMs` from its start to now, waits
  * included, so the turn's span holds every crossing in it; `pausedMs`, how long it waited paused
- * (a wait still open ends now, as for a cancel); the session's agent;
+ * (a wait still open ends now, as for a cancel); the session's Agent and the manifest version it runs;
  * and the turn's totals from the usage ledger (one read, as `/v1/tenant/usage` totals a turn;
  * `steps` are the model calls the gate metered). Clears the turn's timing from `s`.
  */
@@ -30,10 +30,12 @@ export async function endTurn(t, s, turnId, now = new Date()) {
     const facts = {
         ...(elapsed === undefined ? {} : { durationMs: Math.max(0, elapsed), pausedMs: s.pausedMs ?? 0 }),
         agentId: s.agentId,
+        ...(s.definition ? { manifest: { name: s.definition.name, version: s.definition.version } } : {}),
         ...(totals ? { totals: { steps: totals.calls, tokens: totals.tokens, costUsd: totals.costUsd } } : {}),
     };
     delete s.turnStartedAt;
     delete s.pausedMs;
     delete s.turnTrace;
+    delete s.turnCause;
     return facts;
 }

package/dist/tenant/types.d.ts

@@ -1,7 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { HarnessStatus, HostTenant, TenantEnvelope } from "@nylorun/core/contracts";
 import type { HarnessChannel } from "@nylorun/core/harness-api";
-import type { FlowLimits } from "../core/limits.js";
 import type { HarnessPeer } from "../harness-api/server.js";
 import type { HostAuthority } from "../sandbox/join.js";
 import type { SessionStore } from "../store/types.js";
@@ -45,35 +44,31 @@ export interface TenantConfig {
     /**
      * Segment rollover (Model Calls §10): a turn ends its segment at a step boundary after this
      * many steps or milliseconds and continues in a new one, so no advance reaches its
-     * deadline. Default 50 steps or 20 minutes.
+     * deadline. Default the Host tuning's `harnessApi.rolloverSteps` and `rolloverMs` (50 steps,
+     * 20 minutes).
      */
     rollover?: {
         steps?: number;
         ms?: number;
     };
-    /** Retries and timeouts for model calls (Model Calls §5, §6). Defaults in `piModel`. */
-    modelCall?: import("../gates/model-gate.js").ModelCallSettings;
     /**
      * How the Runtime may call MCP servers and HTTP tools (Host settings). Default: http and
      * private addresses allowed.
      */
     delivery?: OutboundPolicy;
-    /** Bounds the default Tenant sweep interval (`sweepIntervalMs`). Default 30 s. */
+    /** Bounds the default Tenant sweep interval (`sweepIntervalMs`). Default: no bound. */
     leaseMs?: number;
-    /** Ownership lease of an advance (§10.6); renewed every third while it runs. Default 30 s. */
+    /**
+     * Ownership lease of an advance (§10.6); renewed every third while it runs. Default the Host
+     * tuning's `tenant.ownerLeaseMs` (30 s).
+     */
     ownerLeaseMs?: number;
     /**
      * Delay between Tenant sweep passes when the Tenant runs its own in-process execution.
-     * Default `min(leaseMs, 5 s)`. A Host-level execution sets its own.
+     * Default `min(leaseMs, sweep.intervalMs)` (Host tuning, 5 s). A Host-level execution sets its
+     * own.
      */
     sweepIntervalMs?: number;
-    /** Operator flow limits (`RuntimeOptions.flow` / `workflows.md` §13). */
-    flow?: Partial<FlowLimits>;
-    /**
-     * Optional env snapshot for `NYLORUN_FLOW_*`. Host passes this; the Runtime
-     * never reads ambient process environment for flow limits.
-     */
-    flowEnv?: Readonly<Record<string, string | undefined>>;
     /**
      * The trusted issuers whose JWTs the Runtime API accepts (Host feature `trusted-issuers`), from
      * the identity file (`NYLORUN_IDENTITY_FILE`). Absent: none.

package/dist/tenant/worker.d.ts

@@ -4,14 +4,6 @@ import type { AdvanceResult, SandboxResult, SandboxTrigger, DurableExecution, St
 import type { Logger } from "./types.js";
 /** This process's Worker id: the `owner` it writes on the sessions it advances (§10.6). */
 export declare const WORKER_ID: string;
-/**
- * Default advance deadline: 50 minutes, below the one-hour inactivity and abort timeouts the
- * Restate adapter sets on the session object, so an advance always ends before Restate gives
- * up on it.
- */
-export declare const DEFAULT_ADVANCE_DEADLINE_MS: number;
-/** Default time an aborted advance has to settle before it is abandoned. */
-export declare const DEFAULT_ADVANCE_GRACE_MS = 30000;
 /** Why an advance's signal aborted (see "Abort reasons" above). */
 export type AdvanceAbortKind = AbortReason;
 /**
@@ -44,15 +36,17 @@ export interface TenantWorker {
     sweep(): Promise<void>;
     /** Reconciles one pod sandbox (F7.2). Only infrastructure errors throw. */
     sandbox?(sandboxId: string, trigger: SandboxTrigger, signal: AbortSignal): Promise<SandboxResult>;
+    /** A durable timer it armed fired (track T4's triggers). Only infrastructure errors throw. */
+    fire?(key: string): Promise<void>;
 }
 export interface TenantWorkersOptions {
     /** Finds or opens a Tenant that is not registered on this process. */
     resolve?: (tenantId: string) => Promise<TenantWorker | undefined>;
-    /** How long one advance may run before its signal aborts. Default `DEFAULT_ADVANCE_DEADLINE_MS`. */
+    /** How long one advance may run before its signal aborts. Default `execution.advanceDeadlineMs` (Host tuning, 50 minutes). */
     advanceDeadlineMs?: number;
     /**
      * How long an advance whose signal aborted has to return before it is abandoned.
-     * Default `DEFAULT_ADVANCE_GRACE_MS`.
+     * Default `execution.advanceGraceMs` (Host tuning, 30 s).
      */
     advanceGraceMs?: number;
     /** Receives a warning for each abandoned advance. */

package/dist/tenant/worker.js

@@ -51,16 +51,9 @@
 import { hostname } from "node:os";
 import { randomBytes } from "node:crypto";
 import { RunAbort } from "@nylorun/harness/api";
+import { hostTuning, MAX_TIMER_MS } from "../tuning.js";
 /** This process's Worker id: the `owner` it writes on the sessions it advances (§10.6). */
 export const WORKER_ID = `worker-${hostname()}-${process.pid}-${randomBytes(4).toString("hex")}`;
-/**
- * Default advance deadline: 50 minutes, below the one-hour inactivity and abort timeouts the
- * Restate adapter sets on the session object, so an advance always ends before Restate gives
- * up on it.
- */
-export const DEFAULT_ADVANCE_DEADLINE_MS = 50 * 60_000;
-/** Default time an aborted advance has to settle before it is abandoned. */
-export const DEFAULT_ADVANCE_GRACE_MS = 30_000;
 /**
  * The abort reason of an advance. A harness run's reason (`RunAbort`) has the same kinds, so the
  * executors read either one.
@@ -109,8 +102,8 @@ export class TenantWorkers {
     graceMs;
     constructor(options = {}) {
         this.options = options;
-        this.deadlineMs = positive("advanceDeadlineMs", options.advanceDeadlineMs ?? DEFAULT_ADVANCE_DEADLINE_MS);
-        this.graceMs = positive("advanceGraceMs", options.advanceGraceMs ?? DEFAULT_ADVANCE_GRACE_MS);
+        this.deadlineMs = positive("advanceDeadlineMs", options.advanceDeadlineMs ?? hostTuning().execution.advanceDeadlineMs);
+        this.graceMs = positive("advanceGraceMs", options.advanceGraceMs ?? hostTuning().execution.advanceGraceMs);
     }
     /** Registers an open Tenant's worker; the returned function unregisters exactly it. */
     register(tenantId, worker) {
@@ -139,6 +132,11 @@ export class TenantWorkers {
             const worker = await this.find(tenantId);
             return worker?.sandbox ? worker.sandbox(sandboxId, trigger, signal) : {};
         },
+        // A timer of a Tenant that is not open here does nothing: the Tenant's sweep arms what is due
+        // once it opens.
+        fire: async (tenantId, key) => {
+            await (await this.find(tenantId))?.fire?.(key);
+        },
     };
     /** Runs one advance under the deadline and the grace period (see the module comment). */
     async bounded(tenantId, sessionId, worker, signal) {
@@ -187,10 +185,8 @@ export class TenantWorkers {
         }
     }
 }
-/** The longest delay `setTimeout` keeps (about 24.8 days). */
-const MAX_TIMEOUT_MS = 2 ** 31 - 1;
 function positive(name, value) {
-    if (!Number.isFinite(value) || value <= 0 || value > MAX_TIMEOUT_MS)
-        throw new Error(`${name} must be positive and at most ${MAX_TIMEOUT_MS}`);
+    if (!Number.isFinite(value) || value <= 0 || value > MAX_TIMER_MS)
+        throw new Error(`${name} must be positive and at most ${MAX_TIMER_MS}`);
     return value;
 }

package/dist/traces/ids.js

@@ -45,7 +45,11 @@ export function parseTraceparent(value) {
         return undefined;
     return { traceId: traceId, spanId: spanId };
 }
-/** The most `tracestate` the Runtime keeps (W3C: 32 members, 512 characters is enough). */
+/**
+ * The most `tracestate` the Runtime keeps: W3C Trace Context (Level 1, section 3.3.1.1) has
+ * vendors propagate at least 512 characters of it, and lets one cut what is past that. A
+ * standard's constant, not a limit (B15).
+ */
 const TRACESTATE_MAX = 512;
 /**
  * The trace context a request's headers carry (R7.4), or undefined without a valid

package/dist/traces/map.d.ts

@@ -5,7 +5,7 @@
  *
  * | Row | Span |
  * | --- | --- |
- * | `turn.completed`, `turn.failed`, `turn.cancelled` | `invoke_agent {agentId}`, the turn's root (INTERNAL) |
+ * | `turn.completed`, `turn.failed`, `turn.cancelled` | `invoke_agent {manifest name}`, the turn's root (INTERNAL) |
  * | `message.assistant`, `model.failed`, `context.compacted` | `chat {model}` (CLIENT) |
  * | `tool.completed` | `execute_tool {toolName}` (INTERNAL) |
  * | `node.completed` | `execute_tool {key}`, a flow's HTTP stage (INTERNAL) |
@@ -25,7 +25,8 @@
  * never carries a person's id (`ownerUserId`, a subject, who approved), an identity header, an
  * idempotency key or a credential value (the log holds none). Content (what a person said, the
  * model's output, tool results and error messages) is left out unless the installation opts in
- * per kind (`TraceContent`), each value cut at 8 KiB. Prompts are not in the log, so never here.
+ * per kind (`TraceContent`), each value cut at the Tenant's Runtime limit `traceContentBytes`
+ * (`SpanSettings.contentBytes`). Prompts are not in the log, so never here.
  */
 import type { LiveEvent } from "@nylorun/core/contracts";
 import { type TraceKey } from "./ids.js";
@@ -39,8 +40,6 @@ export declare const GENAI_SEMCONV = "open-telemetry/semantic-conventions-genai@
 export declare const TRACE_CONTENT_KINDS: readonly ["user", "outputs", "tool-results", "errors"];
 export type TraceContentKind = (typeof TRACE_CONTENT_KINDS)[number];
 export type TraceContent = ReadonlySet<TraceContentKind>;
-/** The most bytes of one content attribute or status message. */
-export declare const CONTENT_MAX_BYTES: number;
 /** OTLP span kinds and status codes (opentelemetry-proto `trace.proto`). */
 export declare const SPAN_KIND: {
     readonly internal: 1;
@@ -93,10 +92,14 @@ export interface TurnTrace {
     /** What a person sent, as `gen_ai.input.messages` (only with `user` content). */
     readonly input?: string;
 }
-/** How spans are made: the trace key and the content the installation exports. */
+/**
+ * How spans are made: the trace key, the content the installation exports, and the most UTF-8
+ * bytes of one content attribute (the Tenant's Runtime limit `traceContentBytes`).
+ */
 export interface SpanSettings {
     readonly key: TraceKey;
     readonly content: TraceContent;
+    readonly contentBytes: number;
 }
 /**
  * The trace of turn `turnId` of session `sessionId`, from its `command.message` when the log has
@@ -109,5 +112,5 @@ export declare function turnTraceOf(settings: SpanSettings, ids: {
 }, message?: Pick<LiveEvent, "payload" | "principal"> | undefined): TurnTrace;
 /** The span `row` makes in its turn's trace, or undefined when it makes none. */
 export declare function spanOf(row: LiveEvent, turn: TurnTrace, settings: SpanSettings): OtlpSpan | undefined;
-/** `value` cut to `CONTENT_MAX_BYTES` of UTF-8, never in the middle of a character. */
-export declare function truncate(value: string): string;
+/** `value` cut to `maxBytes` of UTF-8, never in the middle of a character. */
+export declare function truncate(value: string, maxBytes: number): string;

package/dist/traces/map.js

@@ -7,8 +7,6 @@ export const GENAI_SEMCONV = "open-telemetry/semantic-conventions-genai@6fd0d763
  * (error messages; their codes are always exported).
  */
 export const TRACE_CONTENT_KINDS = ["user", "outputs", "tool-results", "errors"];
-/** The most bytes of one content attribute or status message. */
-export const CONTENT_MAX_BYTES = 8 * 1024;
 /** OTLP span kinds and status codes (opentelemetry-proto `trace.proto`). */
 export const SPAN_KIND = { internal: 1, client: 3 };
 export const STATUS = { unset: 0, ok: 1, error: 2 };
@@ -19,7 +17,7 @@ export const STATUS = { unset: 0, ok: 1, error: 2 };
 export function turnTraceOf(settings, ids, message) {
     const payload = (message?.payload ?? {});
     const inbound = typeof payload.trace?.traceparent === "string" ? parseTraceparent(payload.trace.traceparent) : undefined;
-    const input = settings.content.has("user") && message ? userMessages(payload) : undefined;
+    const input = settings.content.has("user") && message ? userMessages(payload, settings.contentBytes) : undefined;
     return {
         traceId: inbound?.traceId ?? traceIdOf(settings.key, ids.tenantId, ids.sessionId, ids.turnId),
         spanId: turnSpanOf(settings.key, ids.turnId),
@@ -52,17 +50,23 @@ export function spanOf(row, turn, settings) {
     const effectSpan = (effectId) => typeof effectId === "string" && effectId.length > 0
         ? effectSpanOf(settings.key, effectId)
         : eventSpanOf(settings.key, row.sessionId, row.seq);
-    const content = (kind, value) => settings.content.has(kind) && value !== undefined ? truncate(typeof value === "string" ? value : JSON.stringify(value)) : undefined;
+    const content = (kind, value) => settings.content.has(kind) && value !== undefined ? truncate(typeof value === "string" ? value : JSON.stringify(value), settings.contentBytes) : undefined;
     switch (row.type) {
         case "turn.completed":
         case "turn.failed":
         case "turn.cancelled": {
             const status = row.type.slice("turn.".length);
+            // The agent the turn ran: its manifest's name (protocol 16), else the Agent's id.
+            const manifest = p.manifest;
+            const agentName = typeof manifest?.name === "string" ? manifest.name : typeof p.agentId === "string" ? p.agentId : undefined;
             const totals = p.totals;
             const error = row.type === "turn.failed" ? (p.error ?? {}) : undefined;
             const attributes = base
                 .str("gen_ai.operation.name", "invoke_agent")
                 .str("gen_ai.agent.id", p.agentId)
+                .str("gen_ai.agent.name", agentName)
+                // The agent manifest version the turn ran (T3): an Agent moves between versions.
+                .int("nylorun.manifest.version", typeof manifest?.version === "number" ? manifest.version : undefined)
                 .str("nylorun.turn.status", status)
                 .int("nylorun.turn.paused_ms", p.pausedMs)
                 .int("nylorun.turn.steps", totals?.steps)
@@ -78,7 +82,7 @@ export function spanOf(row, turn, settings) {
                 traceId: turn.traceId,
                 spanId: turn.spanId,
                 ...(turn.parentSpanId ? { parentSpanId: turn.parentSpanId } : {}),
-                name: typeof p.agentId === "string" ? `invoke_agent ${p.agentId}` : "invoke_agent",
+                name: agentName === undefined ? "invoke_agent" : `invoke_agent ${agentName}`,
                 kind: SPAN_KIND.internal,
                 ...window(row.time, p.durationMs),
                 attributes: attributes.list,
@@ -132,7 +136,6 @@ export function spanOf(row, turn, settings) {
                 .str("nylorun.effect.id", p.effectId)
                 .int("nylorun.effect.window_ms", p.durationMs)
                 .str("nylorun.compaction.trigger", row.type === "context.compacted" ? p.trigger : undefined)
-                .bool("nylorun.compaction.partial", row.type === "context.compacted" && p.partial === true ? true : undefined)
                 .str("error.type", row.type === "model.failed" ? p.code : undefined)
                 .str("gen_ai.output.messages", output);
             return {
@@ -158,6 +161,7 @@ export function spanOf(row, turn, settings) {
                 .str("gen_ai.agent.id", p.agent?.id)
                 .str("nylorun.tool.kind", kind)
                 .str("nylorun.tool.server", p.server)
+                .str("nylorun.tool.identity", p.tool)
                 .str("nylorun.tool.status", p.status)
                 .int("nylorun.tool.attempts", p.attempts)
                 .int("nylorun.tool.redacted", p.redacted)
@@ -264,7 +268,7 @@ function textPart(value) {
     return { type: "text", content: typeof value === "string" ? value : JSON.stringify(value) };
 }
 /** What a person sent (`command.message`), as `gen_ai.input.messages`. */
-function userMessages(payload) {
+function userMessages(payload, maxBytes) {
     const parts = typeof payload.content === "string"
         ? [{ type: "text", content: payload.content }]
         : Array.isArray(payload.parts)
@@ -274,14 +278,14 @@ function userMessages(payload) {
             : payload.data !== undefined
                 ? [textPart(payload.data)]
                 : undefined;
-    return parts ? truncate(JSON.stringify([{ role: "user", parts }])) : undefined;
+    return parts ? truncate(JSON.stringify([{ role: "user", parts }]), maxBytes) : undefined;
 }
-/** `value` cut to `CONTENT_MAX_BYTES` of UTF-8, never in the middle of a character. */
-export function truncate(value) {
+/** `value` cut to `maxBytes` of UTF-8, never in the middle of a character. */
+export function truncate(value, maxBytes) {
     const bytes = Buffer.from(value, "utf8");
-    if (bytes.length <= CONTENT_MAX_BYTES)
+    if (bytes.length <= maxBytes)
         return value;
-    let end = CONTENT_MAX_BYTES;
+    let end = maxBytes;
     // Back up over continuation bytes (10xxxxxx) to the start of the cut character.
     while (end > 0 && (bytes[end] & 0xc0) === 0x80)
         end -= 1;

package/dist/traces/otlp.d.ts

@@ -28,11 +28,11 @@ export interface OtlpPosterOptions {
     /** `OTEL_EXPORTER_OTLP_HEADERS`. */
     readonly headers?: Readonly<Record<string, string>>;
     readonly resource: TraceResource;
-    /** Tries after the first, for a `429`, a `5xx` or a lost connection. Default 3. */
+    /** Tries after the first, for a `429`, a `5xx` or a lost connection. Default `traces.retries` (Host tuning, 3). */
     readonly retries?: number;
-    /** The wait before the first retry, doubled for each one after. Default 500 ms. */
+    /** The wait before the first retry, doubled for each one after. Default `traces.backoffMs` (500 ms). */
     readonly backoffMs?: number;
-    /** How long one request may take. Default 10 s. */
+    /** How long one request may take. Default `traces.timeoutMs` (10 s). */
     readonly timeoutMs?: number;
     readonly fetch?: typeof fetch;
     readonly log?: (message: string, fields?: Record<string, unknown>) => void;

package/dist/traces/otlp.js

@@ -10,6 +10,7 @@
  */
 import { RUNTIME_VERSION } from "../version.js";
 import { GENAI_SEMCONV } from "./map.js";
+import { hostTuning } from "../tuning.js";
 export const DEFAULT_SERVICE_NAME = "nylorun";
 /** The instrumentation scope of every span. */
 const SCOPE = { name: "@nylorun/runtime", version: RUNTIME_VERSION };
@@ -27,9 +28,10 @@ export function resourceSpans(resource, spans) {
 }
 export function createOtlpPoster(options) {
     const send = options.fetch ?? fetch;
-    const retries = options.retries ?? 3;
-    const backoffMs = options.backoffMs ?? 500;
-    const timeoutMs = options.timeoutMs ?? 10_000;
+    const tuning = hostTuning().traces;
+    const retries = options.retries ?? tuning.retries;
+    const backoffMs = options.backoffMs ?? tuning.backoffMs;
+    const timeoutMs = options.timeoutMs ?? tuning.timeoutMs;
     const log = options.log ?? (() => { });
     return async (spans, signal) => {
         if (spans.length === 0)

package/dist/traces/projector.d.ts

@@ -27,16 +27,21 @@ export interface TraceProjectorOptions {
     readonly post: OtlpPoster;
     /** The Tenant's trace key (`traces/key.ts`). */
     readonly key: () => Promise<TraceKey>;
+    /** The Tenant's Runtime limit `traceContentBytes`, read for each transaction mapped. */
+    readonly contentBytes: () => Promise<number>;
     /** The `command.message` that started turn `turnId`, or undefined when the log has none. */
     readonly turnMessage: (sessionId: string, turnId: string) => Promise<LiveEvent | undefined>;
     readonly content: TraceContent;
-    /** Spans per post. Default 512. */
+    /** Spans per post. Default `traces.batchSpans` (Host tuning, 512). */
     readonly maxBatch?: number;
-    /** How long a span waits for its batch to fill. Default 2 s. */
+    /** How long a span waits for its batch to fill. Default `traces.batchDelayMs` (2 s). */
     readonly maxDelayMs?: number;
-    /** Spans waiting while a post is out, past which the waiting ones are dropped. Default 8192. */
+    /**
+     * Spans waiting while a post is out, past which the waiting ones are dropped. Default
+     * `traces.queuedSpansMax` (8192).
+     */
     readonly maxQueuedSpans?: number;
-    /** Turns whose trace is kept. Default 1024. */
+    /** Turns whose trace is kept. Default `traces.turnCacheSize` (1024). */
     readonly turnCacheSize?: number;
     readonly log?: (message: string, fields?: Record<string, unknown>) => void;
 }

package/dist/traces/projector.js

@@ -1,13 +1,15 @@
 import { spanOf, turnTraceOf } from "./map.js";
+import { hostTuning } from "../tuning.js";
 /** The projector's replication slot. */
 export const TRACE_SLOT = "nylorun_trace_export";
 export function createTraceProjector(options) {
     const { source, post } = options;
     const log = options.log ?? (() => { });
-    const maxBatch = options.maxBatch ?? 512;
-    const maxDelayMs = options.maxDelayMs ?? 2000;
-    const maxQueued = options.maxQueuedSpans ?? 8192;
-    const cacheSize = options.turnCacheSize ?? 1024;
+    const tuning = hostTuning().traces;
+    const maxBatch = options.maxBatch ?? tuning.batchSpans;
+    const maxDelayMs = options.maxDelayMs ?? tuning.batchDelayMs;
+    const maxQueued = options.maxQueuedSpans ?? tuning.queuedSpansMax;
+    const cacheSize = options.turnCacheSize ?? tuning.turnCacheSize;
     const turns = new Map();
     const stopping = new AbortController();
     /** Mapped transactions not yet posted, in commit order. */
@@ -17,6 +19,8 @@ export function createTraceProjector(options) {
     let mapping = Promise.resolve();
     let mappingCount = 0;
     let posting;
+    /** Transactions of the batch being posted: not acknowledged until the post settles. */
+    let postingTxs = 0;
     let timer;
     let active = false;
     let confirmed = null;
@@ -45,7 +49,7 @@ export function createTraceProjector(options) {
         const spans = [];
         if (tx.rows.length === 0)
             return spans;
-        const settings = { key: await options.key(), content: options.content };
+        const settings = { key: await options.key(), content: options.content, contentBytes: await options.contentBytes() };
         for (const record of tx.rows) {
             const row = record.body;
             if (!row || typeof row !== "object" || row.turnId == null)
@@ -72,7 +76,7 @@ export function createTraceProjector(options) {
                         if (of !== activation || stopping.signal.aborted)
                             return;
                         log("trace_projector_retry", { message: error instanceof Error ? error.message : String(error) });
-                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                        await new Promise((resolve) => setTimeout(resolve, tuning.retryMs));
                     }
                 }
                 if (of !== activation)
@@ -115,6 +119,7 @@ export function createTraceProjector(options) {
         const batch = waiting;
         waiting = [];
         waitingSpans = 0;
+        postingTxs = batch.length;
         posting = (async () => {
             const spans = batch.flatMap((tx) => tx.spans);
             // A post a shutdown cut short is not the collector's failure: those rows go again.
@@ -129,6 +134,7 @@ export function createTraceProjector(options) {
             }
         })().finally(() => {
             posting = undefined;
+            postingTxs = 0;
             schedule();
             settle();
         });
@@ -186,7 +192,7 @@ export function createTraceProjector(options) {
         },
         status: () => ({
             active,
-            pendingTxs: waiting.length + mappingCount,
+            pendingTxs: waiting.length + mappingCount + postingTxs,
             pendingSpans: waitingSpans,
             confirmed,
         }),

package/dist/traces/read.js

@@ -1,9 +1,14 @@
 import { traceKey } from "./key.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 import { spanOf, turnTraceOf } from "./map.js";
 import { DEFAULT_SERVICE_NAME, resourceSpans } from "./otlp.js";
 /** Turn `turnId`'s spans as an OTLP `ExportTraceServiceRequest`, from its rows in log order. */
 export async function turnTrace(ctx, sessionId, turnId, events) {
-    const settings = { key: await traceKey(ctx.store), content: ctx.traces?.content ?? new Set() };
+    const settings = {
+        key: await traceKey(ctx.store),
+        content: ctx.traces?.content ?? new Set(),
+        contentBytes: (await ctx.store.tx((t) => readRuntimeLimits(t))).traceContentBytes,
+    };
     const message = events.find((event) => event.type === "command.message");
     const turn = turnTraceOf(settings, { tenantId: ctx.store.tenantId, sessionId, turnId }, message);
     const spans = [];