melchizedek-agents 1.14.0 → 1.15.0

package/.env.example

@@ -251,9 +251,17 @@ PUBLIC_URL=
 # byok: each caller's X-API-Key funds its X-Provider. With A2A_AUTH=secret,
 # byok also scopes data by a hash of that key (the pre-0.16 behaviour).
 # A2A_KEY_MODE=server
-# Bare agent ids that load from the adk_agent_registry table (comma list).
+# Bare agent ids that load from the adk_agent_registry table (comma list),
+# over DATABASE_URL when it is set, else over the Supabase API.
 # Every other bare id is a file; registry:<id> always means the registry.
 # A2A_REGISTRY_AGENTS=
+# The whole syndicate file in one variable, base64 (base64 < agent.yaml), for a
+# host that only takes variables (the published image without a database). It
+# is served as MELCHIZEDEK_AGENT_ID (default agent) and as the default, from a
+# private directory that becomes the agents directory, so MELCHIZEDEK_AGENTS_DIR
+# must be unset. Nested yaml_references travel in its bundled_references.
+# MELCHIZEDEK_AGENT_YAML=
+# MELCHIZEDEK_AGENT_ID=agent
 
 # ── A2A server: binding, limits, lifecycle (all optional) ─────────────────────
 # Without A2A_SERVER_SECRET the server binds 127.0.0.1 only. To bind another

package/CHANGELOG.md

@@ -4,6 +4,80 @@ Consumers of the package read this file; it records changes to the
 **published API surface** (the exports map in `package.json`, the bins,
 the starter pack and the templates), not the repo's full history.
 
+## 1.15.0 — 2026-11-02
+
+**Breaking — read before upgrading**
+
+- **Compaction and masking are on for every agent** (ADR 0152, 0154). A
+  `context:` block used to be allowed on delegates only and nothing
+  compacted unless it set `compact_after_tokens`. Now every agent compacts
+  when a request passes 60% of its model's context window
+  (`lib/models/contextWindow.ts` holds the table; an unknown model counts
+  as 100k; an Ollama model reads its own context length, default 4,096),
+  and a tool result older than the last 6 events and longer than 1,000
+  characters goes to the model as a stub it can fetch back with
+  `recall_tool_result`. `context: off` on an agent restores the old
+  behaviour; `compact_after_tokens: 0` and `mask_over_chars: 0` switch
+  the two off separately; `keep_recent_events` and `summary_model` are
+  the other keys. A request the provider refuses as too long is retried
+  once after a forced compaction.
+- **A `defineTool` result is capped at 20,000 characters** unless the spec
+  sets `maxResultChars` (0 lifts the cap). A tool that returned more now
+  returns the head and a note saying so.
+
+**The prompt prefix is stable** (ADR 0151). Text that changes between an
+agent's requests (`preload_memory`'s recall) leaves the system prompt for
+`ModelRequest.turnNotes`, which every adapter places after the history, so
+a provider's prefix cache covers the tools, the system prompt and the
+history. An `InstructionTool` marked `volatile: true` writes there. The
+Claude adapter sends `cache_control: { type: 'ephemeral' }` on Anthropic's
+own API.
+
+**The summary is sectioned and anchored** (ADR 0153): Intent, Stated facts,
+Decisions, Artifacts, Open, Last state, written from the previous summary
+and the new span only, tool calls and results included, within 1,200 words.
+A summary the model fails to write is skipped (the turn goes on with the
+full history, and the span records `compaction.skipped`) instead of
+replacing the history with nothing. A compacted event carries
+`summaryFormat: 'sections/1'`; the summary's own model call carries
+`llm.purpose: compaction` and `llm.compaction.events`.
+
+**`CapabilityReport.contextWindow`** says how many tokens a model's context
+holds, when the table knows the model.
+
+**The server image is published with every release** (ADR 0149).
+`ghcr.io/jhwadman/melchizedek-serve:<version>` (and `:latest`) for
+linux/amd64 and linux/arm64, with a build-provenance attestation; the
+GitHub Release carries its digest as `melchizedek-serve-v<version>.digest`.
+Pull by that digest.
+
+**A syndicate in one environment variable.** `melchizedek-serve` (and
+`startServer` from `melchizedek-agents/server`) reads
+`MELCHIZEDEK_AGENT_YAML`, the whole syndicate file base64-encoded, and
+serves it as `MELCHIZEDEK_AGENT_ID` (default `agent`) and as the default
+syndicate, from a private directory that becomes the agents directory. A
+definition that does not load stops the boot. It refuses
+`MELCHIZEDEK_AGENTS_DIR` beside it, a syndicate argument other than its
+own, and a nested `yaml_reference` its `bundled_references` does not carry.
+Unset, nothing changes.
+
+**The `Dockerfile` builds again.** `npm ci` ran the package's own
+`prepare` (the build) before the sources were copied, so `docker build`
+failed; both stages now install with `--ignore-scripts`.
+
+**The registry works on any Postgres** (ADR 0150). With `DATABASE_URL`, the
+server loads `registry:<id>` and `A2A_REGISTRY_AGENTS` rows from that
+database (in `MELCHIZEDEK_DB_SCHEMA` when it names one) instead of over the
+Supabase API, and `melchizedek-registry` publishes, rolls back and retires
+there too. Without `DATABASE_URL`, nothing changes. In the library:
+`melchizedek-agents/registry` exports `postgresRegistryReader(pool)` and its
+functions take a supabase-js client or anything with pg's `query` (a
+`pg.Pool`, PGlite); `loadSyndicateFromRegistry(id, { registry })` reads
+through a `RegistryReader`; `postgresStorage` returns `registry`, and
+`createA2AApp` reads `storage.registry` when it is given. A deployment that
+sets both `DATABASE_URL` and Supabase credentials, for different databases,
+now reads the registry from `DATABASE_URL`'s.
+
 ## 1.14.0 — 2026-11-01
 
 **Files in a message.** The A2A server takes inline file parts (`raw`, or 0.3's

package/DOCUMENTATION.md

@@ -1342,6 +1342,19 @@ local conversation keeps talking to the same remote conversation.
 
 `Dockerfile` builds the compiled server and runs it as a non-root user with
 a health check; `compose.yaml` adds optional Ollama and Phoenix (traces).
+Every release also publishes it as `ghcr.io/jhwadman/melchizedek-serve:<version>`
+for linux/amd64 and linux/arm64, with a build-provenance attestation; the
+release carries the digest (`melchizedek-serve-v<version>.digest`), and a
+deployment should pull by that digest. The image needs no agents directory:
+`MELCHIZEDEK_AGENT_YAML` carries the syndicate file base64-encoded and serves
+it as `MELCHIZEDEK_AGENT_ID` (`agent`), or `A2A_REGISTRY_AGENTS` loads it from
+the registry.
+
+```bash
+docker run -p 4000:4000 -e A2A_SERVER_SECRET=… -e GOOGLE_GENAI_API_KEY=… \
+  -e MELCHIZEDEK_AGENT_YAML="$(base64 < agent.yaml)" ghcr.io/jhwadman/melchizedek-serve@sha256:…
+```
+
 `npx melchizedek-db print|apply|status` installs and checks the database.
 Set `PUBLIC_URL`, `A2A_SERVER_SECRET`, `A2A_AUTH`, `A2A_SERVED_AGENTS`,
 `A2A_TRUST_PROXY` and the provider keys from your secret manager; give the orchestrator's stop timeout at least
@@ -1421,6 +1434,15 @@ npx melchizedek-registry rollback desk 3 --note "v4 misroutes refunds"
 npx melchizedek-registry retire desk --yes    # stop serving; history stays
 ```
 
+The server reads the registry from the database its storage is on: over
+`DATABASE_URL` when it is set (any Postgres with the migrations, in
+`MELCHIZEDEK_DB_SCHEMA` when that names a private schema), else over the
+Supabase API with `SUPABASE_URL` and `SUPABASE_SERVICE_ROLE_KEY`.
+`melchizedek-registry` reaches it the same way, `DATABASE_URL` first, and
+the library's functions take either a supabase-js client or a `pg.Pool`
+(`postgresRegistryReader(pool)` is the read side, which `postgresStorage`
+supplies as `registry`).
+
 `publish` and `rollback` validate against the same schema the loader uses
 before anything is written. The author recorded is
 `MELCHIZEDEK_REGISTRY_AUTHOR`, else the local user name; a direct write

package/config/agents/syndicate.schema.json

@@ -1013,31 +1013,42 @@
           "additionalProperties": false
         },
         "context": {
-          "description": "Summarize a long conversation instead of overflowing the window. The orchestrator of a delegate syndicate only.",
-          "type": "object",
-          "properties": {
-            "compact_after_tokens": {
-              "type": "integer",
-              "minimum": 1000,
-              "maximum": 9007199254740991,
-              "description": "Compact when the last request's prompt passed this many tokens."
-            },
-            "keep_recent_events": {
-              "description": "Events kept verbatim after the summary. Default 6.",
-              "type": "integer",
-              "minimum": 1,
-              "maximum": 100
+          "description": "What the model is sent of a long conversation: older tool results as recallable stubs, and a summary of earlier turns past a share of the window; both on by default. \"off\" sends everything as it is.",
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "compact_after_tokens": {
+                  "description": "Compact when the last request's prompt passed this many tokens. Default: 60% of the model's context window; 0 never compacts.",
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 9007199254740991
+                },
+                "keep_recent_events": {
+                  "description": "Events kept verbatim after the summary, and before masking. Default 6.",
+                  "type": "integer",
+                  "minimum": 1,
+                  "maximum": 100
+                },
+                "summary_model": {
+                  "description": "The model that writes the summary. Default: the agent's own.",
+                  "type": "string",
+                  "minLength": 1
+                },
+                "mask_over_chars": {
+                  "description": "An older tool result longer than this many characters is sent as a stub the model can recall. Default 1000; 0 masks none.",
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 9007199254740991
+                }
+              },
+              "additionalProperties": false
             },
-            "summary_model": {
-              "description": "The model that writes the summary. Default: the agent's own.",
+            {
               "type": "string",
-              "minLength": 1
+              "const": "off"
             }
-          },
-          "required": [
-            "compact_after_tokens"
-          ],
-          "additionalProperties": false
+          ]
         },
         "examples": {
           "description": "Few-shot exchanges (input, output) added to every request's instruction.",
@@ -2129,31 +2140,42 @@
             "additionalProperties": false
           },
           "context": {
-            "description": "Summarize a long conversation instead of overflowing the window. The orchestrator of a delegate syndicate only.",
-            "type": "object",
-            "properties": {
-              "compact_after_tokens": {
-                "type": "integer",
-                "minimum": 1000,
-                "maximum": 9007199254740991,
-                "description": "Compact when the last request's prompt passed this many tokens."
-              },
-              "keep_recent_events": {
-                "description": "Events kept verbatim after the summary. Default 6.",
-                "type": "integer",
-                "minimum": 1,
-                "maximum": 100
+            "description": "What the model is sent of a long conversation: older tool results as recallable stubs, and a summary of earlier turns past a share of the window; both on by default. \"off\" sends everything as it is.",
+            "anyOf": [
+              {
+                "type": "object",
+                "properties": {
+                  "compact_after_tokens": {
+                    "description": "Compact when the last request's prompt passed this many tokens. Default: 60% of the model's context window; 0 never compacts.",
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 9007199254740991
+                  },
+                  "keep_recent_events": {
+                    "description": "Events kept verbatim after the summary, and before masking. Default 6.",
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 100
+                  },
+                  "summary_model": {
+                    "description": "The model that writes the summary. Default: the agent's own.",
+                    "type": "string",
+                    "minLength": 1
+                  },
+                  "mask_over_chars": {
+                    "description": "An older tool result longer than this many characters is sent as a stub the model can recall. Default 1000; 0 masks none.",
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 9007199254740991
+                  }
+                },
+                "additionalProperties": false
               },
-              "summary_model": {
-                "description": "The model that writes the summary. Default: the agent's own.",
+              {
                 "type": "string",
-                "minLength": 1
+                "const": "off"
               }
-            },
-            "required": [
-              "compact_after_tokens"
-            ],
-            "additionalProperties": false
+            ]
           },
           "examples": {
             "description": "Few-shot exchanges (input, output) added to every request's instruction.",

package/config/agents/syndicateSchema.yaml

@@ -368,14 +368,19 @@ orchestrator:
   # run_code:
   #   attach: true
 
-  # [optional] Summarize a long conversation instead of overflowing the
-  # window: past `compact_after_tokens` (the last request's prompt), earlier
-  # turns become one summary and the last `keep_recent_events` stay
-  # verbatim. The full history stays stored. Orchestrator of a delegate
-  # syndicate only (ADR 0033).
+  # [optional] What the model is sent of a long conversation; both parts are
+  # on by default, and `context: off` turns both off. A tool result older
+  # than the last `keep_recent_events` events and longer than
+  # `mask_over_chars` goes as a stub the model can read back with
+  # recall_tool_result (0 masks none). Past `compact_after_tokens` (default
+  # 60% of the model's context window; 0 never compacts) the earlier turns
+  # become one sectioned summary, and a prompt that overflows the window
+  # anyway is compacted and retried once. The full history stays stored
+  # either way (ADR 0152, ADR 0153, ADR 0154).
   # context:
-  #   compact_after_tokens: 60000
+  #   mask_over_chars: 1000
   #   keep_recent_events: 6
+  #   compact_after_tokens: 60000
   #   summary_model: "gemini-3.5-flash-lite"   # default: this agent's model
 
   # [optional] "task" on a WORKFLOW NODE: the agent works with its tools

package/dist/lib/a2a/app.d.ts

@@ -46,6 +46,7 @@ import type { TaskStore } from '@a2a-js/sdk/server';
 import type { CompileOptions } from '../compile.ts';
 import type { SessionService } from '../runtime/sessions.ts';
 import type { MemoryService } from '../runtime/memoryService.ts';
+import type { RegistryReader } from '../loadSyndicate.ts';
 import type { SyndicateYamlConfig } from '../loadSyndicate.ts';
 import type { ProviderEndpoint, ProviderId } from '../models/registry.ts';
 import type { TurnLock } from './turnLock.ts';
@@ -128,6 +129,13 @@ export interface A2AAppOptions {
          * route answers 501.
          */
         feedback?: FeedbackStore;
+        /**
+         * Where registry rows load from (`registry:<id>`, `registryAgents`): a
+         * direct connection to the database holding adk_agent_registry.
+         * postgresStorage supplies one on its pool. Without it they load over
+         * the Supabase API (SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY).
+         */
+        registry?: RegistryReader;
         /**
          * One turn at a time per conversation across instances (postgresStorage
          * supplies an advisory lock). Default: a lock in this process.

package/dist/lib/a2a/app.js

@@ -320,7 +320,7 @@ export async function createA2AApp(options) {
     };
     // ── The default syndicate ──────────────────────────────────────────────────
     const config = checkOAuthHosts(options.defaultSyndicate.startsWith('registry:')
-        ? await loadSyndicateFromRegistry(options.defaultSyndicate.slice('registry:'.length), { bindings: bindings() })
+        ? await loadSyndicateFromRegistry(options.defaultSyndicate.slice('registry:'.length), { bindings: bindings(), ...(options.storage?.registry ? { registry: options.storage.registry } : {}) })
         : loadSyndicate(options.defaultSyndicate, { bindings: bindings() }), options.defaultSyndicate);
     // ── Persistence ────────────────────────────────────────────────────────────
     let durableSessions;
@@ -976,7 +976,7 @@ export async function createA2AApp(options) {
         const registryId = agentId.startsWith('registry:') ? agentId.slice('registry:'.length) : registryIds.has(agentId) ? agentId : undefined;
         if (registryId) {
             try {
-                const loaded = await loadSyndicateFromRegistry(registryId, { bindings: bindings() });
+                const loaded = await loadSyndicateFromRegistry(registryId, { bindings: bindings(), ...(options.storage?.registry ? { registry: options.storage.registry } : {}) });
                 return { config: checkOAuthHosts(loaded, `registry:${registryId}`), source: `registry:${registryId}` };
             }
             catch (err) {

package/dist/lib/compile.d.ts

@@ -70,8 +70,8 @@ export declare function withReasoning(agent: {
     generateContentConfig?: object;
 }, model: string | undefined): Record<string, unknown> | undefined;
 /** An agent's `context:` block and its default, owned by the compactor (ADR 0033). */
-export type { ContextConfig } from './runtime/native/compaction.ts';
-import type { ContextConfig } from './runtime/native/compaction.ts';
+export type { ContextConfig, ContextSetting } from './runtime/native/compaction.ts';
+import type { ContextSetting } from './runtime/native/compaction.ts';
 export { DEFAULT_KEEP_RECENT_EVENTS } from './runtime/native/compaction.ts';
 /** True when any agent of a syndicate may pause for approval: a gated tool, or skill scripts. */
 export declare function declaresApprovals(config: SyndicateYamlConfig): boolean;
@@ -202,8 +202,8 @@ export interface AgentSpec {
     disallowTransferToPeers?: boolean;
     /** `code_execution: gemini`. */
     codeExecution?: 'gemini';
-    /** `context:`: compaction (ADR 0033). */
-    context?: ContextConfig;
+    /** `context:`: masking and compaction (ADR 0033, ADR 0154), or `off`. */
+    context?: ContextSetting;
     /** `mode: task`. */
     mode?: 'task';
     /** The syndicate's `max_concurrency`, on its orchestrator (ADR 0116): delegated calls one step runs at once. */

package/dist/lib/compileNative.js

@@ -147,6 +147,9 @@ export function compileNative(spec) {
         agent.fallbackModel = spec.fallbackModel;
     if (spec.context)
         agent.context = spec.context;
+    // The YAML's id when the adapter's differs: the context-window table reads it (ADR 0154).
+    if (spec.modelId && spec.modelId !== model)
+        agent.modelId = spec.modelId;
     if (spec.maxConcurrency !== undefined)
         agent.maxConcurrency = spec.maxConcurrency;
     if (spec.metadata)
@@ -271,7 +274,7 @@ export function nativeAdapterFor(opts = {}, spec) {
                 if (id && !known.has(id))
                     known.set(id, s.resolvedModel);
         }
-        for (const id of [s.fallbackModel, s.context?.summary_model]) {
+        for (const id of [s.fallbackModel, typeof s.context === 'object' ? s.context.summary_model : undefined]) {
             if (!id || known.has(id) || !opts.resolveModel)
                 continue;
             const resolved = opts.resolveModel(id);

package/dist/lib/envSyndicate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * lib/envSyndicate.ts — a syndicate handed to the server in the environment.
+ *
+ * A container started from the published server image has no agents
+ * directory of its own and, without a database, no registry to load from.
+ * `MELCHIZEDEK_AGENT_YAML` carries the whole syndicate file, base64-encoded
+ * (`base64 < agent.yaml`), so a host that only takes environment variables
+ * can still run one. `MELCHIZEDEK_AGENT_ID` names it (default `agent`): the
+ * id callers address at `/<id>/` and list in `A2A_SERVED_AGENTS`.
+ *
+ * The file is written into a fresh private directory (0700, the file 0600)
+ * that becomes the agents directory, then loaded once, so a bad definition
+ * stops the boot instead of failing the first request. Nested
+ * `yaml_reference`s have no files to load from here: each must be carried in
+ * the definition's own `bundled_references`, as a registry
+ * version carries them, or the boot names the missing ones.
+ *
+ * Imports only node built-ins and lib/loadSyndicate.ts.
+ */
+/** The id a syndicate from the environment is served under unless MELCHIZEDEK_AGENT_ID says otherwise. */
+export declare const ENV_AGENT_ID = "agent";
+export interface EnvSyndicate {
+    /** The private directory the file was written to; the server's agents directory. */
+    agentsDir: string;
+    /** The served id. */
+    id: string;
+    /** `<id>.yaml`, the default syndicate's file name. */
+    file: string;
+}
+/**
+ * The syndicate in `MELCHIZEDEK_AGENT_YAML`, written to disk and checked, or
+ * undefined when the variable is unset. Throws naming the variable and, for
+ * a definition that does not load, the loader's own reason.
+ */
+export declare function envSyndicate(env?: NodeJS.ProcessEnv, parent?: string): EnvSyndicate | undefined;

package/dist/lib/envSyndicate.js

@@ -0,0 +1,70 @@
+/**
+ * lib/envSyndicate.ts — a syndicate handed to the server in the environment.
+ *
+ * A container started from the published server image has no agents
+ * directory of its own and, without a database, no registry to load from.
+ * `MELCHIZEDEK_AGENT_YAML` carries the whole syndicate file, base64-encoded
+ * (`base64 < agent.yaml`), so a host that only takes environment variables
+ * can still run one. `MELCHIZEDEK_AGENT_ID` names it (default `agent`): the
+ * id callers address at `/<id>/` and list in `A2A_SERVED_AGENTS`.
+ *
+ * The file is written into a fresh private directory (0700, the file 0600)
+ * that becomes the agents directory, then loaded once, so a bad definition
+ * stops the boot instead of failing the first request. Nested
+ * `yaml_reference`s have no files to load from here: each must be carried in
+ * the definition's own `bundled_references`, as a registry
+ * version carries them, or the boot names the missing ones.
+ *
+ * Imports only node built-ins and lib/loadSyndicate.ts.
+ */
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadSyndicate } from './loadSyndicate.js';
+/** The id a syndicate from the environment is served under unless MELCHIZEDEK_AGENT_ID says otherwise. */
+export const ENV_AGENT_ID = 'agent';
+/** Same charset as an A2A agent id (lib/a2a/app.ts isValidAgentId), without `:` and `.`, which name registry rows and files. */
+const AGENT_ID = /^[A-Za-z0-9_-]{1,120}$/;
+const BASE64 = /^[A-Za-z0-9+/_-]+={0,2}$/;
+/**
+ * The syndicate in `MELCHIZEDEK_AGENT_YAML`, written to disk and checked, or
+ * undefined when the variable is unset. Throws naming the variable and, for
+ * a definition that does not load, the loader's own reason.
+ */
+export function envSyndicate(env = process.env, parent = tmpdir()) {
+    const encoded = env.MELCHIZEDEK_AGENT_YAML?.replace(/\s+/g, '');
+    if (!encoded)
+        return undefined;
+    const id = env.MELCHIZEDEK_AGENT_ID?.trim() || ENV_AGENT_ID;
+    if (!AGENT_ID.test(id)) {
+        throw new Error('MELCHIZEDEK_AGENT_ID must be 1-120 letters, digits, _ or -.');
+    }
+    if (env.MELCHIZEDEK_AGENTS_DIR?.trim()) {
+        throw new Error('MELCHIZEDEK_AGENT_YAML and MELCHIZEDEK_AGENTS_DIR are both set: the syndicate comes from one place. Unset one of them.');
+    }
+    // Node's base64 decoder takes the URL-safe alphabet too.
+    const bytes = BASE64.test(encoded) ? Buffer.from(encoded, 'base64') : undefined;
+    if (!bytes?.length) {
+        throw new Error('MELCHIZEDEK_AGENT_YAML must be the syndicate file base64-encoded (base64 < agent.yaml), not the YAML itself.');
+    }
+    const agentsDir = mkdtempSync(join(parent, 'melchizedek-agent-'));
+    const file = `${id}.yaml`;
+    writeFileSync(join(agentsDir, file), bytes, { mode: 0o600 });
+    let config;
+    try {
+        config = loadSyndicate(file, { agentsDir, shippedFallback: false });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`MELCHIZEDEK_AGENT_YAML does not load: ${message}`);
+    }
+    const bundled = config.bundled_references ?? {};
+    const missing = (config.subagents ?? [])
+        .map((s) => s.yaml_reference)
+        .filter((ref) => typeof ref === 'string' && !Object.hasOwn(bundled, ref));
+    if (missing.length) {
+        throw new Error(`MELCHIZEDEK_AGENT_YAML references nested syndicates it does not carry: ${missing.join(', ')}. `
+            + 'Put each in the definition\'s bundled_references, or serve from the registry (A2A_REGISTRY_AGENTS).');
+    }
+    return { agentsDir, id, file };
+}

package/dist/lib/loadSyndicate.d.ts

@@ -5,7 +5,7 @@ import type { OpenApiConfig } from './tools/openapiTools.ts';
 import type { McpAuthConfig } from './tools/oauthTools.ts';
 import type { McpTransportKind } from './tools/mcpTransports.ts';
 import type { McpServerConfig } from './tools/mcpToolFactory.ts';
-import type { ContextConfig, ExampleConfig } from './compile.ts';
+import type { ContextSetting, ExampleConfig } from './compile.ts';
 export type { OpenApiConfig } from './tools/openapiTools.ts';
 export type { SkillsConfig } from './tools/skillToolset.ts';
 import type { WorkflowConfig } from './workflowConfig.ts';
@@ -182,8 +182,8 @@ export interface AgentYamlConfig {
     run_code?: {
         attach?: boolean;
     };
-    /** Compact a long conversation into a summary past a token threshold (ADR 0033). Delegate orchestrator only. */
-    context?: ContextConfig;
+    /** What the model is sent of a long conversation: masking and compaction, both on by default (ADR 0033, ADR 0152, ADR 0154), or `off`. */
+    context?: ContextSetting;
     /** `task`: the agent works until it calls finish_task; its arguments are the node's output. Workflow nodes only. */
     mode?: 'task';
     /** Few-shot exchanges added to every request's instruction (ADK's ExampleTool). */
@@ -415,8 +415,20 @@ export declare function nestedLoader(config: SyndicateYamlConfig, fromFiles?: (r
  */
 export declare function validateRegistryConfig(config: Record<string, any>): void;
 /**
- * Loads a syndicate configuration from the Supabase registry.
- * @param registryId The document ID in the adk_agent_registry table
- * @param options Load options (bindings and overrides)
+ * Where registry rows are read from over a direct database connection
+ * (DATABASE_URL): `postgresRegistryReader(pool)` in lib/registry.ts, which
+ * postgresStorage supplies as `registry`.
  */
-export declare function loadSyndicateFromRegistry(registryId: string, options?: LoadSyndicateOptions): Promise<SyndicateYamlConfig>;
+export interface RegistryReader {
+    /** The active definition of `id`, or with `version` that stored version; undefined when there is none. */
+    definition(id: string, version?: number): Promise<unknown>;
+}
+/**
+ * Loads a syndicate configuration from the registry: through `registry`
+ * (a direct Postgres connection) when given, else over the Supabase API.
+ * @param registryId The document ID in the adk_agent_registry table; `<id>@<version>` loads one stored version
+ * @param options Load options (bindings and overrides), and the reader
+ */
+export declare function loadSyndicateFromRegistry(registryId: string, options?: LoadSyndicateOptions & {
+    registry?: RegistryReader;
+}): Promise<SyndicateYamlConfig>;

package/dist/lib/loadSyndicate.js

@@ -400,13 +400,22 @@ export function validateRegistryConfig(config) {
     }
 }
 /**
- * Loads a syndicate configuration from the Supabase registry.
- * @param registryId The document ID in the adk_agent_registry table
- * @param options Load options (bindings and overrides)
+ * Loads a syndicate configuration from the registry: through `registry`
+ * (a direct Postgres connection) when given, else over the Supabase API.
+ * @param registryId The document ID in the adk_agent_registry table; `<id>@<version>` loads one stored version
+ * @param options Load options (bindings and overrides), and the reader
  */
 export async function loadSyndicateFromRegistry(registryId, options = {}) {
+    const { registry, ...loadOptions } = options;
+    if (registry) {
+        const pinnedRef = /^(.+)@(\d+)$/.exec(registryId);
+        const definition = pinnedRef ? await registry.definition(pinnedRef[1], Number(pinnedRef[2])) : await registry.definition(registryId);
+        if (definition === undefined || definition === null)
+            throw new Error(`Registry document ${registryId} not found`);
+        return resolveAndValidate(definition, `registry:${registryId}`, loadOptions);
+    }
     if (!hasSupabaseCredentials()) {
-        throw new Error('Supabase credentials not available for registry loading.');
+        throw new Error('No registry to load from: set DATABASE_URL (a direct Postgres connection), or SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY.');
     }
     const supabaseUrl = process.env.SUPABASE_URL;
     const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
@@ -427,5 +436,5 @@ export async function loadSyndicateFromRegistry(registryId, options = {}) {
     }
     // The registry row is the live copy of a file (scripts/deploy_agent.ts), so
     // it answers to the same schema; the label says where the bad copy lives.
-    return resolveAndValidate(data.yaml_content, `registry:${registryId}`, options);
+    return resolveAndValidate(data.yaml_content, `registry:${registryId}`, loadOptions);
 }

package/dist/lib/models/capabilities.d.ts

@@ -48,6 +48,8 @@ export interface CapabilityReport {
     dropped: string[];
     /** Declared client-side tools; portable across every path. */
     portable: string[];
+    /** The tokens the model's context holds (lib/models/contextWindow.ts); absent for a provider the table does not know. */
+    contextWindow?: number;
 }
 export declare function describeCapabilities(model: string, tools?: readonly string[], opts?: {
     callerKey?: boolean;

package/dist/lib/models/capabilities.js

@@ -21,6 +21,7 @@ import { PROVIDERS } from './providerMap.js';
 import { gatewaySearch, planTransport } from './gateway.js';
 import { nativeSearchOn, PLATFORMS_FOR, platformFromEnv } from './endpoints.js';
 import { claudeGeneration, claudeUrlImagesOn } from './claudeModels.js';
+import { contextWindowOf } from './contextWindow.js';
 /** The platform a direct path uses (ADR 0023); a misconfigured one reads as direct here, the doctor reports it. */
 function directPlatform(provider) {
     try {
@@ -79,6 +80,7 @@ export function describeCapabilities(model, tools = [], opts = {}) {
         native,
         dropped,
         portable,
+        ...(contextWindowOf(model) !== undefined ? { contextWindow: contextWindowOf(model) } : {}),
     };
 }
 /**

package/dist/lib/models/chatCompletionsAdapter.js

@@ -896,6 +896,19 @@ export class ChatCompletionsAdapter {
                     return;
             }
         });
+        // This step's notes, after the history: joined to a last user message's
+        // text, or a user message of their own after tool results, so the cached
+        // prefix before them holds. Never a trailing system message: some
+        // OpenAI-compatible servers take system first only.
+        if (request.turnNotes) {
+            const last = messages[messages.length - 1];
+            if (last?.role === 'user' && typeof last.content === 'string')
+                last.content = `${last.content}\n\n${request.turnNotes}`;
+            else if (last?.role === 'user' && Array.isArray(last.content))
+                last.content.push({ type: 'text', text: request.turnNotes });
+            else
+                messages.push({ role: 'user', content: request.turnNotes });
+        }
         if (system.length > 0)
             messages.unshift({ role: 'system', content: system.join('\n\n') });
         return messages;