@vincemakes/kiso-runtime 0.41.2 → 0.42.0

package/dist/agent.d.ts

@@ -89,6 +89,12 @@ export interface AgentDefinition {
         readonly tool: string;
         readonly line: string;
     }>;
+    /** 0.42.0: "off" withholds the generated "Tool use:" block entirely —
+     *  no fixed directives, no snippets, no guidelines — so the system
+     *  prompt is exactly the configured text (a host matching another
+     *  system byte for byte). The tool schemas still ride the request.
+     *  Default "on". Type-only additive; never part of the profile digest. */
+    readonly toolTable?: "on" | "off";
     /** E1: loaded extensions — their tools merge into the registry (a name
      *  collision with a built-in is a loud startup error), their hooks
      *  compose after the agent's own (the existing come first), their approvals join the

package/dist/agent.js

@@ -178,6 +178,7 @@ export class AgentRuntime {
             ...(this.#definition.maxRetries !== undefined ? { maxRetries: this.#definition.maxRetries } : {}),
             ...(this.#definition.streamIdleMs !== undefined ? { streamIdleMs: this.#definition.streamIdleMs } : {}),
             ...(this.#definition.toolRules !== undefined ? { toolRules: this.#definition.toolRules } : {}),
+            ...(this.#definition.toolTable !== undefined ? { toolTable: this.#definition.toolTable } : {}),
             ...(this.#definition.extensions !== undefined ? { extensions: this.#definition.extensions } : {}),
         };
         // 0.40.0: the last bill's time rides the RECORD, not the event.

package/dist/compose.d.ts

@@ -3,7 +3,7 @@
  * from session.ts: the extension system-prompt appends, the extension
  * hook composition (the existing come first), and the loop's microcompact config lookup.
  */
-import type { ApprovalChain, Event, HookHost, KisoExtension, ToolRegistry } from "@vincemakes/kiso-core";
+import type { Adapter, ApprovalChain, Event, HookHost, KisoExtension, ToolRegistry } from "@vincemakes/kiso-core";
 import type { SessionConfig } from "./session.js";
 /**
  * 0.1.40 (R-C item 1) — the tool substitution table: vocabulary rows, each
@@ -29,7 +29,12 @@ export type ToolRules = ReadonlyArray<{
  *  then the tool table (generated machinery sits BETWEEN the base and the
  *  extension appends). One function, so an in-band summary outside a run
  *  (ADR-0055 A2, /compact) sends the exact prefix a run sends. */
-export declare function runBasePrompt(systemPrompt: string | undefined, registry: ToolRegistry, rules?: ToolRules): string | undefined;
+/** 0.42.0: `"off"` leaves the base prompt exactly as configured — no
+ *  "Tool use:" block, no snippets, no guidelines — for a host whose prompt
+ *  must match another system's byte for byte. The tool SCHEMAS still ride
+ *  the request; only the generated prose is withheld. */
+export type ToolTableMode = "on" | "off";
+export declare function runBasePrompt(systemPrompt: string | undefined, registry: ToolRegistry, rules?: ToolRules, table?: ToolTableMode): string | undefined;
 /** The table, or "" when the registry is empty (no vocabulary, no tools). */
 export declare function composeToolTable(registry: ToolRegistry, rules?: ToolRules): string;
 /**
@@ -37,7 +42,19 @@ export declare function composeToolTable(registry: ToolRegistry, rules?: ToolRul
  * order, \n\n-joined — deterministic (same extension list → same prompt).
  * No appends → the base passes through byte-identical.
  */
+/** An extension's append as text: a string as is, a function evaluated
+ *  NOW (0.42.0 — the per-run seam; call this once per composition). */
+export declare function appendOf(extension: KisoExtension): string | undefined;
 export declare function composeSystemPrompt(base: string | undefined, extensions: readonly KisoExtension[]): string | undefined;
+/** The base and the append texts, \n\n-joined; no appends → the base as is. */
+export declare function joinPrompt(base: string | undefined, appends: readonly string[]): string | undefined;
+/** 0.42.0: the OUTERMOST adapter layer — `compose` runs exactly once per
+ *  provider attempt (a retry is a new attempt) and its result is the
+ *  request's system prompt as every inner layer, the tracer first, sees
+ *  it: what the trace records is what the model was sent, by construction.
+ *  Never a getter on the config — the kernel and the tracer each read
+ *  their field twice, and an observer must not run the product's code. */
+export declare function promptPerAttempt(adapter: Adapter, compose: () => string | undefined): Adapter;
 /**
  * E1: extension hooks compose AFTER the agent's own (the existing come first — the existing
  * hook sees every event first). Observers all run, in order; onUserMessage

package/dist/compose.js

@@ -3,11 +3,9 @@
  * from session.ts: the extension system-prompt appends, the extension
  * hook composition (the existing come first), and the loop's microcompact config lookup.
  */
-/** The base a run's system prompt is composed on: the session's prompt,
- *  then the tool table (generated machinery sits BETWEEN the base and the
- *  extension appends). One function, so an in-band summary outside a run
- *  (ADR-0055 A2, /compact) sends the exact prefix a run sends. */
-export function runBasePrompt(systemPrompt, registry, rules = []) {
+export function runBasePrompt(systemPrompt, registry, rules = [], table = "on") {
+    if (table === "off")
+        return systemPrompt;
     const toolTable = composeToolTable(registry, rules);
     return toolTable === "" ? systemPrompt : systemPrompt === undefined ? toolTable : `${systemPrompt}\n\n${toolTable}`;
 }
@@ -37,12 +35,39 @@ export function composeToolTable(registry, rules = []) {
  * order, \n\n-joined — deterministic (same extension list → same prompt).
  * No appends → the base passes through byte-identical.
  */
+/** An extension's append as text: a string as is, a function evaluated
+ *  NOW (0.42.0 — the per-run seam; call this once per composition). */
+export function appendOf(extension) {
+    const append = extension.systemPrompt?.append;
+    return typeof append === "function" ? append() : append;
+}
 export function composeSystemPrompt(base, extensions) {
-    const appends = extensions.flatMap((e) => (e.systemPrompt?.append === undefined ? [] : [e.systemPrompt.append]));
+    return joinPrompt(base, extensions.flatMap((e) => {
+        const text = appendOf(e);
+        return text === undefined ? [] : [text];
+    }));
+}
+/** The base and the append texts, \n\n-joined; no appends → the base as is. */
+export function joinPrompt(base, appends) {
     if (appends.length === 0)
         return base;
     return base === undefined ? appends.join("\n\n") : `${base}\n\n${appends.join("\n\n")}`;
 }
+/** 0.42.0: the OUTERMOST adapter layer — `compose` runs exactly once per
+ *  provider attempt (a retry is a new attempt) and its result is the
+ *  request's system prompt as every inner layer, the tracer first, sees
+ *  it: what the trace records is what the model was sent, by construction.
+ *  Never a getter on the config — the kernel and the tracer each read
+ *  their field twice, and an observer must not run the product's code. */
+export function promptPerAttempt(adapter, compose) {
+    return {
+        stream: (options) => {
+            const systemPrompt = compose();
+            const { systemPrompt: _fixed, ...rest } = options;
+            return adapter.stream(systemPrompt === undefined ? rest : { ...rest, systemPrompt });
+        },
+    };
+}
 /**
  * E1: extension hooks compose AFTER the agent's own (the existing come first — the existing
  * hook sees every event first). Observers all run, in order; onUserMessage

package/dist/run.js

@@ -7,7 +7,7 @@ import { denialResult, loop } from "@vincemakes/kiso-core";
 import { ABORTED, MergedSignal, abortable, openRunId } from "./recovery.js";
 import { resolveReasoning } from "./provider/metadata.js";
 import { deriveRecoveryPlan, invocationSeqOf } from "./recovery-plan.js";
-import { composeApprovalChain, composeSystemPrompt, runBasePrompt } from "./compose.js";
+import { appendOf, composeApprovalChain, joinPrompt, promptPerAttempt, runBasePrompt } from "./compose.js";
 import { truncationGuard } from "./truncation-guard.js";
 import { overflowBelt } from "./overflow-belt.js";
 import { DEFAULT_STREAM_IDLE_MS, idleGuard } from "./idle-guard.js";
@@ -88,16 +88,33 @@ export class Run {
             // session's base prompt and the extension appends: generated
             // machinery never outranks the deliberate extension text (the E2
             // "append lands at the END" contract holds). "" when empty.
-            const basePrompt = runBasePrompt(this.#config.systemPrompt, this.#config.registry, this.#config.toolRules ?? []);
+            const basePrompt = runBasePrompt(this.#config.systemPrompt, this.#config.registry, this.#config.toolRules ?? [], this.#config.toolTable ?? "on");
             // E3 — the ledger's parts: the base as CONFIGURED (what the CLI
             // handed the runtime — the tool table is generated machinery, R3)
             // and the extension appends in load order (R4 attribution). The
             // composed string below is their result; the ledger counts the
             // parts, observation-only. exactOptionalPropertyTypes: an absent
             // surface is an absent key — never an explicit undefined (R9).
-            const rentParts = {
-                ...(this.#config.systemPrompt !== undefined ? { base: this.#config.systemPrompt } : {}),
-                appends: (this.#config.extensions ?? []).flatMap((e) => e.systemPrompt?.append === undefined ? [] : [{ name: e.name, text: e.systemPrompt.append }]),
+            // 0.42.0 (the products' request #11): an extension's append is
+            // evaluated ONCE PER PROVIDER ATTEMPT, never during a tool — by
+            // `snapshot`, which the outermost adapter layer (promptPerAttempt,
+            // in loopConfig) calls as it builds each attempt's request. The
+            // one evaluation composes the request's prompt from the fixed
+            // base AND fills the rent ledger's `appends`: the tracer, inside
+            // that layer, records the bytes the model was sent. The in-band
+            // summary reads the last attempt's snapshot (the prefix the run
+            // last sent) or takes one if no attempt has happened yet.
+            const rentParts = { ...(this.#config.systemPrompt !== undefined ? { base: this.#config.systemPrompt } : {}), appends: [] };
+            let lastPrompt;
+            let taken = false;
+            const snapshot = () => {
+                const appends = (this.#config.extensions ?? []).flatMap((e) => {
+                    const text = appendOf(e);
+                    return text === undefined ? [] : [{ name: e.name, text }];
+                });
+                rentParts.appends = appends;
+                taken = true;
+                return (lastPrompt = joinPrompt(basePrompt, appends.map((a) => a.text)));
             };
             // E1 (1.2.0): the request tracer — the observation ledger. It
             // sits at the adapter boundary; the model-visible byte stream is
@@ -124,7 +141,6 @@ export class Run {
             // E2: the session's own systemPrompt first, then every extension
             // append in LOAD order — deterministic (same extensions → same
             // prompt); no appends → byte-identical to the extension-less run.
-            const systemPrompt = composeSystemPrompt(basePrompt, this.#config.extensions ?? []);
             const approvalChain = composeApprovalChain(this.#config.extensions ?? []);
             // ADR-0055 Amendment 1 (A1b): the compaction point the kernel asks
             // before every request — the run's own prefix, so an in-band
@@ -139,7 +155,7 @@ export class Run {
                 wireReasoning = undefined;
             }
             const compact = this.#session.compactionPoint({
-                ...(systemPrompt !== undefined ? { systemPrompt } : {}),
+                systemPrompt: () => (taken ? lastPrompt : snapshot()),
                 tools: () => this.#config.registry.snapshot().specs,
                 ...(wireReasoning !== undefined ? { reasoning: wireReasoning } : {}),
                 signal,
@@ -154,10 +170,9 @@ export class Run {
                 // ADR-0055 Amendment 2 (decision 3): the overflow belt sits outside
                 // the guards, so a stall or a cut on a request known not to fit is
                 // classified as the overflow it is, and the tracer records that.
-                adapter: traceGuard(tracer, overflowBelt(truncationGuard(idleGuard(this.#adapter, this.#config.streamIdleMs ?? DEFAULT_STREAM_IDLE_MS)), () => this.#session.overflowMeasure())), // tracer assigned above, before loopConfig
+                adapter: promptPerAttempt(traceGuard(tracer, overflowBelt(truncationGuard(idleGuard(this.#adapter, this.#config.streamIdleMs ?? DEFAULT_STREAM_IDLE_MS)), () => this.#session.overflowMeasure())), snapshot), // tracer assigned above, before loopConfig
                 model: this.#config.model,
                 sessionId: this.#session.id, // P3: tools see their session (ToolContext.sessionId)
-                ...(systemPrompt !== undefined ? { systemPrompt } : {}),
                 registry: this.#config.registry,
                 ...(this.#config.hooks !== undefined ? { hooks: this.#config.hooks } : {}),
                 ...(this.#config.maxTurns !== undefined ? { maxTurns: this.#config.maxTurns } : {}),

package/dist/session.d.ts

@@ -147,7 +147,8 @@ export declare class AgentSession {
      * standing prune here, for SDK callers — the kernel no longer has one.
      */
     compactionPoint(run: {
-        readonly systemPrompt?: string;
+        /** 0.42.0: a thunk — evaluated ONCE per in-band summary (the run's per-attempt snapshot). */
+        readonly systemPrompt?: string | (() => string | undefined);
         readonly tools: () => readonly ToolSpec[];
         readonly reasoning?: {
             readonly thinking?: "adaptive" | "enabled" | "disabled";
@@ -559,6 +560,8 @@ export interface SessionConfig {
         readonly tool: string;
         readonly line: string;
     }>;
+    /** 0.42.0: "off" withholds the generated tool table entirely (see AgentDefinition). */
+    readonly toolTable?: "on" | "off";
     /**
      * E1: loaded extensions — their tools join the registry (idempotently;
      * a collision with a built-in name was already rejected at agent

package/dist/session.js

@@ -394,12 +394,13 @@ export class AgentSession {
         const boundary = checkpointBoundarySeq(events, { keepTokens: tail });
         if (boundary === undefined)
             return null;
+        const summaryPrompt = typeof run.systemPrompt === "function" ? run.systemPrompt() : run.systemPrompt;
         let path;
         let result;
         try {
             ({ result, path } = await this.#checkpointCall({
                 messages,
-                inBand: { ...(run.systemPrompt !== undefined ? { systemPrompt: run.systemPrompt } : {}), tools: run.tools() },
+                inBand: { ...(summaryPrompt !== undefined ? { systemPrompt: summaryPrompt } : {}), tools: run.tools() },
                 ...(run.reasoning !== undefined ? { reasoning: run.reasoning } : {}),
                 serialized: () => serializeCovered({ events, prevPoint: lastSummaryPoint(events), boundary }),
                 serializedReasoning: true,
@@ -842,7 +843,7 @@ export class AgentSession {
             // the one fallback. The budget is unchanged: measured for the
             // manual gesture, fixed for the policy (0.39.2).
             const cfg = this.#effectiveConfig();
-            const systemPrompt = composeSystemPrompt(runBasePrompt(cfg.systemPrompt, cfg.registry, cfg.toolRules ?? []), cfg.extensions ?? []);
+            const systemPrompt = composeSystemPrompt(runBasePrompt(cfg.systemPrompt, cfg.registry, cfg.toolRules ?? [], cfg.toolTable ?? "on"), cfg.extensions ?? []);
             const wire = cfg.reasoning === undefined ? undefined : resolveReasoning(binding.model, cfg.reasoning, binding.baseUrl);
             const { result: call, path } = await this.#checkpointCall({
                 messages: this.projected(),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-runtime",
-	"version": "0.41.2",
+	"version": "0.42.0",
 	"description": "kiso runtime \u2014 durable multi-turn agent sessions: AgentDefinition, AgentRuntime, AgentSession, Run, append-only JSONL store.",
 	"type": "module",
 	"license": "MIT",
@@ -25,12 +25,12 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-core": "0.41.2"
+		"@vincemakes/kiso-core": "0.42.0"
 	},
 	"peerDependencies": {
-		"@vincemakes/kiso-provider-anthropic": "0.41.2",
-		"@vincemakes/kiso-provider-openai": "0.41.2",
-		"@vincemakes/kiso-provider-openai-responses": "0.41.2"
+		"@vincemakes/kiso-provider-anthropic": "0.42.0",
+		"@vincemakes/kiso-provider-openai": "0.42.0",
+		"@vincemakes/kiso-provider-openai-responses": "0.42.0"
 	},
 	"peerDependenciesMeta": {
 		"@vincemakes/kiso-provider-anthropic": {
@@ -44,7 +44,7 @@
 		}
 	},
 	"devDependencies": {
-		"@vincemakes/kiso-evals": "0.41.2",
+		"@vincemakes/kiso-evals": "0.42.0",
 		"@types/node": "^26.1.2",
 		"typescript": "^5.7.2",
 		"vitest": "^3.0.0"