@tangle-network/agent-app 0.1.3 → 0.1.4

package/dist/knowledge-loop/index.d.ts

@@ -0,0 +1,208 @@
+import { KnowledgeResearchLoopContext, AddSourceTextInput, SourceAdapter, RunKnowledgeResearchLoopOptions, KnowledgeResearchLoopResult } from '@tangle-network/agent-knowledge';
+import { KnowledgeSourceSpec, AgentKnowledgeConfig } from '../config/index.js';
+import '../knowledge/index.js';
+import '@tangle-network/agent-eval';
+import '../model-BOP69mVu.js';
+
+/**
+ * `@tangle-network/agent-app/knowledge-loop` — wire the declarative
+ * `AgentKnowledgeConfig` to a running, source-grounded, eval-gated knowledge
+ * acquisition loop.
+ *
+ * This module does NOT implement a loop. `@tangle-network/agent-knowledge`
+ * already ships `runKnowledgeResearchLoop` — the source-grounded,
+ * propose-don't-apply primitive (sources become immutable records first; only
+ * accepted `---FILE: knowledge/...---` write blocks are applied; lint +
+ * validation + optional readiness gate every iteration). It is pluggable on two
+ * seams: a `SourceAdapter[]` (how raw bytes/text become curated source records —
+ * text by default, audio/video/image adapters added by the consumer) and a
+ * `step` decider (the per-iteration policy: an agentic judge, a sandbox run, or
+ * a deterministic gate — the loop deliberately bakes none).
+ *
+ * `createKnowledgeLoop(config.knowledge, deps)` is the thin mapper between the
+ * two:
+ *
+ *  - `config.knowledge.sources` → adapter selection. The text adapter is the
+ *    default; `deps.adapters` is the multimodal seam (prepend an audio/video/
+ *    image `SourceAdapter` and the loop ingests that media). agent-app bakes no
+ *    media handler — it's a parameter.
+ *  - `config.knowledge.loop` → `runKnowledgeResearchLoop` options. `goal` maps
+ *    to the loop goal, `minConfidence` to the gate threshold, `freshness` is
+ *    threaded to the decider so a per-source-freshness policy can read it.
+ *  - `deps.decide` → the pluggable gate. DEFAULT is a reviewer policy
+ *    (agent-knowledge's propose-don't-apply posture): a candidate carrying
+ *    confidence below `minConfidence` is gated OUT (its proposal text is
+ *    dropped — sources are still recorded, because grounding is never the thing
+ *    we gate); at/above threshold it is accepted and the loop applies the write
+ *    blocks. Swap in an agentic judge or a sandbox run by passing your own
+ *    `decide`.
+ *  - `deps.driver` → the agent-runtime turn driver (this repo's `../runtime`
+ *    `runAppToolLoop` seam, or any compatible driver) the decider invokes for
+ *    the loop's agent turns. Optional; a deterministic / sandbox decider needs
+ *    no model turns and omits it.
+ *
+ * Layering: agent-knowledge and agent-runtime are PEER dependencies, never
+ * bundled. This module imports only TYPES + the loop entry from agent-knowledge
+ * and stays substrate-free behind the `decide` / `driver` / `adapters` seams.
+ */
+
+/**
+ * A research candidate the decider evaluates before the loop applies it. This is
+ * the propose-don't-apply unit: notes + the sources discovered this iteration +
+ * the proposed write blocks, each carrying a confidence the gate scores against
+ * the configured `minConfidence`.
+ */
+interface KnowledgeCandidate {
+    /** Human-readable research transcript for this iteration. */
+    notes?: string;
+    /**
+     * Textual source artifacts to register as immutable sources BEFORE any
+     * proposal is applied. Recording these is grounding, not the gated step — a
+     * rejected candidate still keeps its sources (so the next iteration is better
+     * grounded). The decider may not strip these.
+     */
+    sourceTexts?: AddSourceTextInput[];
+    /** Local files to register as immutable sources (same grounding posture). */
+    sourcePaths?: string[];
+    /**
+     * Safe-write-protocol text (`---FILE: knowledge/...---` blocks). This IS the
+     * gated step: the default decider drops it when `confidence < minConfidence`.
+     */
+    proposalText?: string;
+    /**
+     * Aggregate confidence in this candidate's proposal, in [0, 1]. The default
+     * reviewer gate compares this to `minConfidence`. A candidate with no
+     * `proposalText` needs no confidence (nothing is gated).
+     */
+    confidence?: number;
+    /** The researcher's signal that the goal is met; ends the loop. */
+    done?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** The verdict a gate returns for one candidate. */
+interface KnowledgeGateVerdict {
+    /** Whether the candidate's proposal is accepted (applied) or gated out. */
+    accepted: boolean;
+    /** Why — surfaced in the decision metadata for audit. */
+    reason: string;
+    /** The confidence the gate scored (echoed for telemetry). */
+    confidence: number;
+    /** The threshold it was scored against. */
+    minConfidence: number;
+}
+/**
+ * The pluggable acquisition policy. Given the loop context (current index, lint,
+ * validation, freshness target, the driver), produce a candidate AND a gate
+ * verdict on it. This is the seam an agentic judge or a sandbox run plugs into;
+ * the default {@link createReviewerDecider} is a confidence gate.
+ */
+interface KnowledgeDecider {
+    (input: KnowledgeDeciderInput): Promise<KnowledgeDecision> | KnowledgeDecision;
+}
+interface KnowledgeDeciderInput {
+    /** The agent-knowledge loop context for this iteration. */
+    context: KnowledgeResearchLoopContext;
+    /** The acquisition goal (from `config.loop.goal` or a deps fallback). */
+    goal: string;
+    /** The confidence threshold a proposal must clear to be applied. */
+    minConfidence: number;
+    /** The freshness target (`config.loop.freshness`), if set. */
+    freshness?: string;
+    /** The configured sources, for a decider that fetches/selects among them. */
+    sources: KnowledgeSourceSpec[];
+    /** The agent-runtime turn driver, if one was supplied to the loop. */
+    driver?: KnowledgeLoopDriver;
+}
+interface KnowledgeDecision {
+    /** The candidate the policy produced (may be empty to end the loop). */
+    candidate: KnowledgeCandidate;
+    /** The gate's verdict on the candidate's proposal. */
+    verdict: KnowledgeGateVerdict;
+}
+/**
+ * The agent-runtime turn driver seam. This is exactly `../runtime`'s
+ * `runAppToolLoop` shape (a bounded, awaitable tool-driving turn loop over a
+ * model). Typed structurally so a decider can drive the loop's agent turns
+ * without this module importing the runtime engine. A deterministic / sandbox
+ * decider may omit it.
+ */
+interface KnowledgeLoopDriver {
+    (opts: {
+        systemPrompt: string;
+        userMessage: string;
+    }): Promise<{
+        finalText: string;
+    }>;
+}
+interface CreateKnowledgeLoopDeps {
+    /**
+     * The knowledge-base root the loop reads/writes (an agent-knowledge layout).
+     * Required — agent-knowledge owns disk; agent-app owns only the wiring.
+     */
+    root: string;
+    /**
+     * The per-iteration policy. Defaults to {@link createReviewerDecider} keyed on
+     * the config's `minConfidence`. Pass your own to use an agentic judge or a
+     * sandbox run.
+     */
+    decide?: KnowledgeDecider;
+    /**
+     * Extra source adapters (audio/video/image/PDF/...). The text adapter is
+     * always present as the fallback; these are tried first so a multimodal
+     * source is claimed by its adapter. This is the multimodal seam.
+     */
+    adapters?: SourceAdapter[];
+    /** The agent-runtime turn driver for the loop's agent turns. */
+    driver?: KnowledgeLoopDriver;
+    /**
+     * Fallback goal when `config.loop.goal` is unset. agent-knowledge requires a
+     * goal; this keeps the loop runnable for a config with only requirement specs.
+     */
+    defaultGoal?: string;
+    /** Default confidence threshold when `config.loop.minConfidence` is unset. */
+    defaultMinConfidence?: number;
+    /** Max research iterations (forwarded to agent-knowledge). Default 3. */
+    maxIterations?: number;
+    /** Actor stamped on the loop's knowledge events. */
+    actor?: string;
+    /** Abort the loop. */
+    signal?: AbortSignal;
+    /** Per-step hook (forwarded to agent-knowledge's `onStep`). */
+    onStep?: RunKnowledgeResearchLoopOptions['onStep'];
+}
+/** The handle `createKnowledgeLoop` returns. */
+interface KnowledgeLoop {
+    /** Run the acquisition loop to completion and return the agent-knowledge result. */
+    run(): Promise<KnowledgeResearchLoopResult>;
+    /** The resolved goal the loop pursues. */
+    readonly goal: string;
+    /** The resolved confidence gate threshold. */
+    readonly minConfidence: number;
+    /** The adapters the loop uses (consumer extras first, text last). */
+    readonly adapters: SourceAdapter[];
+}
+/**
+ * The default gate — agent-knowledge's propose-don't-apply reviewer posture as a
+ * confidence threshold. A candidate's `proposalText` is applied only when its
+ * `confidence` is at/above `minConfidence`; otherwise the proposal is gated out
+ * (sources are still recorded). A candidate with no `proposalText` is trivially
+ * accepted (nothing to gate). This is the floor policy; swap in an agentic judge
+ * or a sandbox-run decider via `deps.decide` for richer review.
+ */
+declare function reviewCandidate(candidate: KnowledgeCandidate, minConfidence: number): KnowledgeGateVerdict;
+/**
+ * Wrap a candidate-producing policy in the default reviewer gate. The policy
+ * decides WHAT to propose (notes, sources, proposalText, confidence); the gate
+ * decides whether the proposal is APPLIED. Use this when you have a proposer but
+ * want the standard confidence gate; pass a full {@link KnowledgeDecider} to
+ * `deps.decide` to own the gate too.
+ */
+declare function createReviewerDecider(propose: (input: KnowledgeDeciderInput) => Promise<KnowledgeCandidate> | KnowledgeCandidate): KnowledgeDecider;
+/**
+ * Build a runnable knowledge-acquisition loop from the product's
+ * `AgentKnowledgeConfig` and a small set of seams. Maps config → agent-knowledge
+ * `runKnowledgeResearchLoop` options; never reimplements the loop.
+ */
+declare function createKnowledgeLoop(knowledge: AgentKnowledgeConfig, deps: CreateKnowledgeLoopDeps): KnowledgeLoop;
+
+export { type CreateKnowledgeLoopDeps, type KnowledgeCandidate, type KnowledgeDecider, type KnowledgeDeciderInput, type KnowledgeDecision, type KnowledgeGateVerdict, type KnowledgeLoop, type KnowledgeLoopDriver, createKnowledgeLoop, createReviewerDecider, reviewCandidate };

package/dist/knowledge-loop/index.js

@@ -0,0 +1,11 @@
+import {
+  createKnowledgeLoop,
+  createReviewerDecider,
+  reviewCandidate
+} from "../chunk-EEPJGZJW.js";
+export {
+  createKnowledgeLoop,
+  createReviewerDecider,
+  reviewCandidate
+};
+//# sourceMappingURL=index.js.map

package/dist/knowledge-loop/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/model-BOP69mVu.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Resolve the model config a Tangle agent's sandbox/runtime runs on.
+ *
+ * Every Tangle agent product resolves the SAME thing from env: the Tangle Router
+ * (OpenAI-compatible, metered at the platform markup against a single
+ * `TANGLE_API_KEY`) by default, with a direct-Anthropic BYOK escape hatch. The
+ * shape feeds the sandbox SDK's `backend.model`. Lifted here so no product
+ * hand-rolls the env parsing + the router default.
+ */
+interface TangleModelConfig {
+    /** The Tangle Router is OpenAI-compatible → driven via `openai-compat`.
+     *  `anthropic` is the BYOK escape hatch. */
+    provider: 'openai-compat' | 'anthropic';
+    model: string;
+    apiKey: string;
+    baseUrl: string;
+}
+interface ResolveModelOptions {
+    /** Env to read (defaults to process.env). */
+    env?: Record<string, string | undefined>;
+    /** Router base URL default when `TANGLE_ROUTER_BASE_URL` is unset. */
+    defaultRouterBaseUrl?: string;
+}
+declare const DEFAULT_TANGLE_ROUTER_BASE_URL = "https://router.tangle.tools/v1";
+/**
+ * Resolve the model config from env. DEFAULT path (`MODEL_PROVIDER` unset or
+ * `openai-compat`/`tangle-router`/`tcloud`): the Tangle Router, authenticated
+ * with `TANGLE_API_KEY`, model from `MODEL_NAME`. BYOK path
+ * (`MODEL_PROVIDER=anthropic`): direct Anthropic with `ANTHROPIC_API_KEY` +
+ * `ANTHROPIC_BASE_URL`. Throws (fail-loud) on a missing required var so a
+ * misconfigured deploy fails at boot, not mid-turn.
+ */
+declare function resolveTangleModelConfig(opts?: ResolveModelOptions): TangleModelConfig;
+
+export { DEFAULT_TANGLE_ROUTER_BASE_URL as D, type ResolveModelOptions as R, type TangleModelConfig as T, resolveTangleModelConfig as r };

package/dist/preset-cloudflare/index.d.ts

@@ -0,0 +1,244 @@
+import { KeyProvisioner, KeyCrypto, WorkspaceKeyManager, WorkspaceKeyStore } from '../billing/index.js';
+import { KnowledgeStateAccessor } from '../knowledge/index.js';
+import { c as AppToolHandlers } from '../types-CeWor4bQ.js';
+import { KvLike } from '../web/index.js';
+import '@tangle-network/agent-eval';
+
+/**
+ * `@tangle-network/agent-app/preset-cloudflare` — the batteries-included default
+ * stack.
+ *
+ * Every fleet agent runs the SAME backend: Cloudflare D1 (SQLite) through
+ * Drizzle for state, a KV namespace as the artifact vault, AES-GCM field crypto
+ * for PII, and per-workspace budget-capped model keys. The other agent-app
+ * modules are pure SEAMS — `./tools` needs an `AppToolHandlers`, `./knowledge`
+ * needs a `KnowledgeStateAccessor`, `./billing` needs a `WorkspaceKeyStore` +
+ * `KeyCrypto`. This module is the ONE implementation of those seams against the
+ * house stack, so a consumer that runs D1 + KV stands the whole shell up with
+ * config + bindings and ZERO handler code.
+ *
+ * Layering:
+ *  - Drizzle is a PEER (the consumer installs `drizzle-orm`, never bundled). The
+ *    schema is therefore expressed two ways that need no import here: the plain
+ *    DDL ({@link PRESET_MIGRATION_SQL}) a consumer runs to create the tables, and
+ *    a {@link createPresetDrizzleSchema} factory that takes the consumer's
+ *    `drizzle-orm/sqlite-core` builder module and returns the typed tables. The
+ *    column names in {@link PRESET_TABLES} are the contract the handlers,
+ *    accessor, and DDL all agree on.
+ *  - D1 + KV are STRUCTURAL: {@link D1Like} (Cloudflare `D1Database` satisfies it)
+ *    and `KvLike` from `../web` (Cloudflare `KVNamespace` satisfies it). No
+ *    `@cloudflare/workers-types` dependency.
+ *  - Crypto/billing reuse `../crypto` + `../billing` exactly — this only wires
+ *    them to the D1 key table.
+ */
+
+/** A prepared, bound D1 statement. */
+interface D1PreparedLike {
+    bind(...values: unknown[]): D1PreparedLike;
+    first<T = Record<string, unknown>>(colName?: string): Promise<T | null>;
+    run(): Promise<unknown>;
+    all<T = Record<string, unknown>>(): Promise<{
+        results: T[];
+    }>;
+}
+/** The D1 surface the preset needs. Cloudflare `D1Database` satisfies it. */
+interface D1Like {
+    prepare(query: string): D1PreparedLike;
+}
+/** The preset table + column names — the contract the DDL, Drizzle schema,
+ *  handlers, and accessor share. Exposed so a consumer can reference a column
+ *  without a string literal. */
+declare const PRESET_TABLES: {
+    readonly proposals: {
+        readonly name: "proposals";
+        readonly columns: {
+            readonly id: "id";
+            readonly workspaceId: "workspace_id";
+            readonly threadId: "thread_id";
+            readonly type: "type";
+            readonly title: "title";
+            readonly description: "description";
+            readonly status: "status";
+            readonly createdBy: "created_by";
+            readonly createdAt: "created_at";
+        };
+    };
+    readonly threads: {
+        readonly name: "threads";
+        readonly columns: {
+            readonly id: "id";
+            readonly workspaceId: "workspace_id";
+            readonly title: "title";
+            readonly createdAt: "created_at";
+        };
+    };
+    readonly knowledge: {
+        readonly name: "knowledge";
+        readonly columns: {
+            readonly id: "id";
+            readonly workspaceId: "workspace_id";
+            readonly path: "path";
+            readonly kind: "kind";
+            readonly label: "label";
+            readonly content: "content";
+            readonly createdAt: "created_at";
+        };
+    };
+    readonly deadlines: {
+        readonly name: "deadlines";
+        readonly columns: {
+            readonly id: "id";
+            readonly workspaceId: "workspace_id";
+            readonly threadId: "thread_id";
+            readonly title: "title";
+            readonly dueDate: "due_date";
+            readonly priority: "priority";
+            readonly status: "status";
+            readonly createdAt: "created_at";
+        };
+    };
+    readonly workspaceKeys: {
+        readonly name: "workspace_keys";
+        readonly columns: {
+            readonly id: "id";
+            readonly workspaceId: "workspace_id";
+            readonly keyId: "key_id";
+            readonly keyEncrypted: "key_encrypted";
+            readonly budgetUsd: "budget_usd";
+            readonly expiresAt: "expires_at";
+            readonly revokedAt: "revoked_at";
+            readonly createdAt: "created_at";
+        };
+    };
+};
+/**
+ * Plain DDL for the preset schema — run by a consumer to create the tables with
+ * ZERO drizzle (`for (const sql of PRESET_MIGRATION_SQL) await db.prepare(sql).run()`,
+ * or paste into a `.sql` migration). One statement per table so D1's
+ * single-statement `prepare` accepts each. Matches {@link PRESET_TABLES} exactly.
+ */
+declare const PRESET_MIGRATION_SQL: readonly string[];
+/** A chainable column builder — every modifier returns the builder so calls
+ *  like `.notNull().default('pending')` typecheck. The concrete drizzle builders
+ *  satisfy this structurally. */
+interface DrizzleColumnLike {
+    primaryKey: () => DrizzleColumnLike;
+    notNull: () => DrizzleColumnLike;
+    default: (v: unknown) => DrizzleColumnLike;
+}
+/** The shape of a `drizzle-orm/sqlite-core` module — the few builders the
+ *  preset schema uses. The consumer passes the real module; agent-app never
+ *  imports it (it stays a peer). */
+interface DrizzleSqliteCoreLike {
+    sqliteTable: (name: string, columns: Record<string, DrizzleColumnLike>) => unknown;
+    text: (name?: string) => DrizzleColumnLike;
+    integer: (name?: string, config?: unknown) => DrizzleColumnLike;
+    real: (name?: string) => DrizzleColumnLike;
+}
+/**
+ * Build the typed Drizzle schema for the preset, given the consumer's
+ * `drizzle-orm/sqlite-core` module. Returns one table object per
+ * {@link PRESET_TABLES} entry — pass to `drizzle(db, { schema })` for typed
+ * queries, or to drizzle-kit for migration generation. agent-app never imports
+ * drizzle; the builder module is the seam.
+ *
+ * ```ts
+ * import * as d from 'drizzle-orm/sqlite-core'
+ * const schema = createPresetDrizzleSchema(d)
+ * ```
+ */
+declare function createPresetDrizzleSchema(d: DrizzleSqliteCoreLike): {
+    threads: unknown;
+    proposals: unknown;
+    knowledge: unknown;
+    deadlines: unknown;
+    workspaceKeys: unknown;
+};
+/** The KV-backed vault. `KvLike` (from `../web`) is the structural KV contract;
+ *  Cloudflare `KVNamespace` satisfies it. Artifacts are stored under their path. */
+type VaultKv = KvLike;
+interface PresetToolHandlerOptions {
+    /** The D1 database (Cloudflare `D1Database` satisfies {@link D1Like}). */
+    db: D1Like;
+    /** The KV namespace used as the artifact vault. */
+    vault: VaultKv;
+    /** Id generator. Default `crypto.randomUUID`. Injectable for deterministic tests. */
+    newId?: () => string;
+    /** Clock (epoch ms). Default `Date.now`. Injectable for deterministic tests. */
+    now?: () => number;
+    /** Vault path prefix for `render_ui` artifacts. Default `'ui'`. */
+    uiPathPrefix?: string;
+    /** Vault path prefix for `add_citation` artifacts. Default `'citations'`. */
+    citationPathPrefix?: string;
+}
+/**
+ * The default {@link AppToolHandlers} for the house stack:
+ *  - `submit_proposal`   → insert a `proposals` row (`status='pending'`), deduped
+ *                          on (workspace, title) so a retried turn doesn't double-queue.
+ *  - `schedule_followup` → insert a `deadlines` row, deduped on (workspace, title, due_date).
+ *  - `render_ui`         → write the schema JSON as a `ui/<thread>/<slug>.json`
+ *                          vault artifact AND a `knowledge` row pointing at it.
+ *  - `add_citation`      → write the quote as a `citations/<slug>.json` artifact AND
+ *                          a `knowledge` row.
+ *
+ * Returns the EXACT persisted content from `render_ui` (per the seam contract) so
+ * a completion oracle sees real bytes. Pure seam wiring: a consumer that runs
+ * D1 + KV gets all four tools with no handler code.
+ */
+declare function createPresetToolHandlers(opts: PresetToolHandlerOptions): AppToolHandlers;
+interface PresetKnowledgeAccessorOptions {
+    db: D1Like;
+    /** The active workspace — every `count` is scoped to it. */
+    workspaceId: string;
+    /** Workspace config the `satisfiedBy: { config }` rules read. A resolved
+     *  object (dot-path lookup), or a function the accessor calls per path. */
+    config: Record<string, unknown> | ((path: string) => unknown);
+    /** The default workspace fk column a `count` rule scopes on when its rule
+     *  omits `where`. Default `'workspace_id'` (the preset schema convention). */
+    defaultWhereColumn?: string;
+}
+/**
+ * The {@link KnowledgeStateAccessor} over the preset D1 schema — the seam that
+ * lets the declarative `satisfiedBy` rules resolve with ZERO consumer code:
+ *  - `config(path)` reads the supplied workspace config by dot-path.
+ *  - `count({ table, where, statusIn })` runs `SELECT count(*)` scoped to the
+ *    active workspace (the rule's `where` column, default `workspace_id`),
+ *    optionally filtered to `statusIn` via a parameterized `IN (...)`.
+ *
+ * Identifiers (table/column) are validated against a safe pattern before
+ * interpolation — they originate from the product's own config, never model
+ * input, but we fail loud rather than build a malformed/injectable query.
+ */
+declare function createD1KnowledgeStateAccessor(opts: PresetKnowledgeAccessorOptions): KnowledgeStateAccessor;
+/** Build the {@link KeyCrypto} the billing key store uses — AES-256-GCM field
+ *  crypto bound to the product's 64-char-hex `ENCRYPTION_KEY` (or a resolver).
+ *  This is the concrete impl behind the `../billing` `KeyCrypto` seam. */
+declare function createPresetFieldCrypto(key: string | (() => string)): KeyCrypto;
+/**
+ * The {@link WorkspaceKeyStore} over the preset `workspace_keys` table — the
+ * persistence seam the per-workspace key manager needs. "Active" = a row with a
+ * null `revoked_at`. Pure D1 wiring; no key minting (that's the provisioner).
+ */
+declare function createPresetWorkspaceKeyStore(db: D1Like): WorkspaceKeyStore;
+interface PresetBillingOptions {
+    db: D1Like;
+    /** The key provisioner (`@tangle-network/tcloud`'s client satisfies it structurally). */
+    provisioner: KeyProvisioner;
+    /** Field-crypto key (64-char hex) or resolver — encrypts the minted key at rest. */
+    encryptionKey: string | (() => string);
+    /** Default monthly USD allowance when a call doesn't specify one. */
+    defaultBudgetUsd: number;
+    /** Injectable clock. */
+    now?: () => Date;
+    /** tcloud product the key is scoped to. Default `'router'`. */
+    product?: string;
+}
+/**
+ * Stand up the per-workspace budget-capped {@link WorkspaceKeyManager} on the
+ * house stack: the preset `workspace_keys` D1 store + AES-GCM field crypto +
+ * the consumer's tcloud provisioner. The mint/rotate/rollover/usage LOGIC lives
+ * in `../billing`; this only binds it to the preset table + crypto.
+ */
+declare function createPresetWorkspaceKeyManager(opts: PresetBillingOptions): WorkspaceKeyManager;
+
+export { type D1Like, type D1PreparedLike, type DrizzleColumnLike, type DrizzleSqliteCoreLike, PRESET_MIGRATION_SQL, PRESET_TABLES, type PresetBillingOptions, type PresetKnowledgeAccessorOptions, type PresetToolHandlerOptions, type VaultKv, createD1KnowledgeStateAccessor, createPresetDrizzleSchema, createPresetFieldCrypto, createPresetToolHandlers, createPresetWorkspaceKeyManager, createPresetWorkspaceKeyStore };

package/dist/preset-cloudflare/index.js

@@ -0,0 +1,23 @@
+import {
+  PRESET_MIGRATION_SQL,
+  PRESET_TABLES,
+  createD1KnowledgeStateAccessor,
+  createPresetDrizzleSchema,
+  createPresetFieldCrypto,
+  createPresetToolHandlers,
+  createPresetWorkspaceKeyManager,
+  createPresetWorkspaceKeyStore
+} from "../chunk-EZXN67KE.js";
+import "../chunk-EAJSWUU5.js";
+import "../chunk-ZJGY7OMZ.js";
+export {
+  PRESET_MIGRATION_SQL,
+  PRESET_TABLES,
+  createD1KnowledgeStateAccessor,
+  createPresetDrizzleSchema,
+  createPresetFieldCrypto,
+  createPresetToolHandlers,
+  createPresetWorkspaceKeyManager,
+  createPresetWorkspaceKeyStore
+};
+//# sourceMappingURL=index.js.map

package/dist/preset-cloudflare/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime/index.d.ts

@@ -1,39 +1,6 @@
+export { D as DEFAULT_TANGLE_ROUTER_BASE_URL, R as ResolveModelOptions, T as TangleModelConfig, r as resolveTangleModelConfig } from '../model-BOP69mVu.js';
 import { d as AppToolOutcome } from '../types-CeWor4bQ.js';
 
-/**
- * Resolve the model config a Tangle agent's sandbox/runtime runs on.
- *
- * Every Tangle agent product resolves the SAME thing from env: the Tangle Router
- * (OpenAI-compatible, metered at the platform markup against a single
- * `TANGLE_API_KEY`) by default, with a direct-Anthropic BYOK escape hatch. The
- * shape feeds the sandbox SDK's `backend.model`. Lifted here so no product
- * hand-rolls the env parsing + the router default.
- */
-interface TangleModelConfig {
-    /** The Tangle Router is OpenAI-compatible → driven via `openai-compat`.
-     *  `anthropic` is the BYOK escape hatch. */
-    provider: 'openai-compat' | 'anthropic';
-    model: string;
-    apiKey: string;
-    baseUrl: string;
-}
-interface ResolveModelOptions {
-    /** Env to read (defaults to process.env). */
-    env?: Record<string, string | undefined>;
-    /** Router base URL default when `TANGLE_ROUTER_BASE_URL` is unset. */
-    defaultRouterBaseUrl?: string;
-}
-declare const DEFAULT_TANGLE_ROUTER_BASE_URL = "https://router.tangle.tools/v1";
-/**
- * Resolve the model config from env. DEFAULT path (`MODEL_PROVIDER` unset or
- * `openai-compat`/`tangle-router`/`tcloud`): the Tangle Router, authenticated
- * with `TANGLE_API_KEY`, model from `MODEL_NAME`. BYOK path
- * (`MODEL_PROVIDER=anthropic`): direct Anthropic with `ANTHROPIC_API_KEY` +
- * `ANTHROPIC_BASE_URL`. Throws (fail-loud) on a missing required var so a
- * misconfigured deploy fails at boot, not mid-turn.
- */
-declare function resolveTangleModelConfig(opts?: ResolveModelOptions): TangleModelConfig;
-
 /**
  * OpenAI-compatible stream → `LoopEvent` adapter, for NON-sandbox copilots.
  *
@@ -216,4 +183,4 @@ interface StreamAppToolLoopOptions<Raw> {
  */
 declare function streamAppToolLoop<Raw>(opts: StreamAppToolLoopOptions<Raw>): AsyncGenerator<StreamLoopYield<Raw>, void, unknown>;
 
-export { type AppToolLoopOptions, DEFAULT_TANGLE_ROUTER_BASE_URL, type LoopEvent, type LoopToolCall, type OpenAICompatStreamTurnOptions, type OpenAIStreamChunk, type ResolveModelOptions, type StreamAppToolLoopOptions, type StreamLoopYield, type TangleModelConfig, type ToolLoopResult, createOpenAICompatStreamTurn, resolveTangleModelConfig, runAppToolLoop, streamAppToolLoop, toLoopEvents };
+export { type AppToolLoopOptions, type LoopEvent, type LoopToolCall, type OpenAICompatStreamTurnOptions, type OpenAIStreamChunk, type StreamAppToolLoopOptions, type StreamLoopYield, type ToolLoopResult, createOpenAICompatStreamTurn, runAppToolLoop, streamAppToolLoop, toLoopEvents };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "packageManager": "pnpm@10.33.4",
   "description": "Application-shell framework for Tangle agent products: a bounded tool loop, the structured agent→app tool side channel, integration-hub client, per-workspace billing, and crypto — composed over the Tangle agent substrate through typed seams.",
   "keywords": [
@@ -66,6 +66,21 @@
       "import": "./dist/knowledge/index.js",
       "default": "./dist/knowledge/index.js"
     },
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "import": "./dist/config/index.js",
+      "default": "./dist/config/index.js"
+    },
+    "./knowledge-loop": {
+      "types": "./dist/knowledge-loop/index.d.ts",
+      "import": "./dist/knowledge-loop/index.js",
+      "default": "./dist/knowledge-loop/index.js"
+    },
+    "./preset-cloudflare": {
+      "types": "./dist/preset-cloudflare/index.d.ts",
+      "import": "./dist/preset-cloudflare/index.js",
+      "default": "./dist/preset-cloudflare/index.js"
+    },
     "./billing": {
       "types": "./dist/billing/index.d.ts",
       "import": "./dist/billing/index.js",
@@ -106,15 +121,26 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
+    "@tangle-network/agent-eval": "^0.70.0",
+    "@tangle-network/agent-integrations": "^0.32.0",
+    "@tangle-network/agent-knowledge": "^1.5.2",
     "@types/node": "^25.6.0",
     "tsup": "^8.0.0",
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0",
-    "@tangle-network/agent-integrations": "^0.32.0",
-    "@tangle-network/agent-eval": "^0.70.0"
+    "vitest": "^3.0.0"
   },
   "peerDependencies": {
+    "@tangle-network/agent-eval": ">=0.50.0",
     "@tangle-network/agent-integrations": ">=0.32.0",
-    "@tangle-network/agent-eval": ">=0.50.0"
+    "@tangle-network/agent-knowledge": ">=1.5.0",
+    "@tangle-network/agent-runtime": ">=0.21.0"
+  },
+  "peerDependenciesMeta": {
+    "@tangle-network/agent-knowledge": {
+      "optional": true
+    },
+    "@tangle-network/agent-runtime": {
+      "optional": true
+    }
   }
 }