@tangle-network/agent-app 0.1.2 → 0.1.4

package/dist/config/index.d.ts

@@ -0,0 +1,367 @@
+import { KnowledgeRequirementSpec } from '../knowledge/index.js';
+export { SatisfiedByRule } from '../knowledge/index.js';
+import { T as TangleModelConfig } from '../model-BOP69mVu.js';
+import '@tangle-network/agent-eval';
+
+/**
+ * `@tangle-network/agent-app/config` — the typed `AgentAppConfig` contract.
+ *
+ * This is the single declarative DATA surface a coding agent fills to stand up a
+ * new agent product. Everything an agent product otherwise hand-rolls as
+ * imperative wiring — who the agent is, which proposal types exist and which are
+ * approval-gated, what knowledge the control loop requires, which integrations
+ * are connectable, how the model resolves — is expressed here as plain data the
+ * rest of agent-app's modules consume through their typed seams:
+ *
+ *  - `identity`     → the system-prompt + disclaimer surface the chat pipeline reads.
+ *  - `taxonomy`     → which `submit_proposal` types the `./tools` side channel
+ *                     accepts, and which the approval queue treats as regulated
+ *                     (certified-human-gated).
+ *  - `knowledge`    → the `./knowledge` requirement specs that gate the loop, plus
+ *                     the acquisition-loop goal/threshold the researcher pursues.
+ *  - `integrations` → which `@tangle-network/agent-integrations` catalog kinds the
+ *                     product enables.
+ *  - `ui`           → whether the agent may emit generated UI (`render_ui`).
+ *  - `model`        → the `./runtime` `TangleModelConfig` (or null to resolve from env).
+ *
+ * Layering: this module is the CONTRACT only — pure types + an identity helper.
+ * It introduces no behavior and no engine dependency; it REUSES the existing
+ * `KnowledgeRequirementSpec`/`SatisfiedByRule` (from `../knowledge`) and
+ * `TangleModelConfig` (from `../runtime`) rather than redefining them, so the
+ * config a product authors is the exact shape those modules already consume.
+ * Steps that build the composer/loader read this file as the schema floor.
+ */
+
+/**
+ * Who the agent is, as data. Composed into the chat pipeline's system prompt;
+ * never baked into agent-app (a domain value, per the layering contract).
+ */
+interface AgentIdentityConfig {
+    /** Product/agent name, e.g. `"WinFinance Ops Partner"`. Shown to the user and
+     *  available to the system-prompt builder. */
+    name: string;
+    /** One-paragraph persona statement — the agent's role, voice, and remit. The
+     *  spine of the system prompt. */
+    persona: string;
+    /** Additional system-prompt fragments appended verbatim after the persona
+     *  (standing workflows, hard rules, tone). Order is preserved. Optional. */
+    systemPromptFragments?: string[];
+    /** Named disclaimers the product surfaces (e.g. a regulatory human-in-the-loop
+     *  notice). Keyed by a stable id (`compliance`, `not-advice`, …) so the chat
+     *  pipeline / UI can select one by name. Values are the literal text. Optional. */
+    disclaimers?: Record<string, string>;
+}
+/**
+ * The proposal taxonomy, as data. `proposalTypes` is the closed set of
+ * `submit_proposal` types the `./tools` side channel accepts; `regulatedTypes`
+ * is the subset that is approval-gated — the executor refuses to run one without
+ * a certified human approver. `regulatedTypes` MUST be a subset of
+ * `proposalTypes` (validated by the loader step; not enforced at the type level).
+ */
+interface AgentTaxonomyConfig {
+    /** Every proposal type this product can emit, e.g.
+     *  `['propose_swap', 'contact_lead', 'policy_change']`. The closed allow-list
+     *  the tool layer validates a `submit_proposal` call against. */
+    proposalTypes: string[];
+    /** The subset of `proposalTypes` that is regulated → cannot execute without a
+     *  certified-human approver. The approval executor reads this to decide which
+     *  proposals are fail-loud certified-gated. */
+    regulatedTypes: string[];
+}
+/** A knowledge source the acquisition loop / researcher may draw on. */
+interface KnowledgeSourceSpec {
+    /** Where the source lives — a URL, a `vault://` path, an integration ref, etc.
+     *  Opaque to agent-app; the consumer's loader resolves it. */
+    uri: string;
+    /** Optional source classifier the researcher uses to pick a fetch strategy,
+     *  e.g. `'web'`, `'vault'`, `'regulation'`, `'integration'`. Free-form. */
+    kind?: string;
+}
+/**
+ * The knowledge-acquisition loop config — the goal the researcher pursues and
+ * the gate it must clear before the loop is considered satisfied. All optional;
+ * a product with only static requirement specs omits it.
+ */
+interface KnowledgeLoopConfig {
+    /** The acquisition goal in natural language, e.g.
+     *  `"ground every quoted premium against a real policy record"`. */
+    goal?: string;
+    /** The minimum aggregate confidence [0, 1] the loop must reach to pass its
+     *  gate. The runtime control loop blocks below this. Default decided by the
+     *  consumer's loop wiring when omitted. */
+    minConfidence?: number;
+    /** How fresh acquired knowledge must be, e.g. `'static'`, `'7d'`, `'session'`.
+     *  Free-form; the consumer's loop interprets it. */
+    freshness?: string;
+}
+/**
+ * The knowledge surface, as data. `sources` are what the researcher may read;
+ * `requirements` are the declarative `./knowledge` specs that gate the control
+ * loop (reused verbatim — the same `KnowledgeRequirementSpec` the gate scores);
+ * `loop` configures the acquisition pass.
+ */
+interface AgentKnowledgeConfig {
+    /** Sources the acquisition loop / researcher may draw on. */
+    sources: KnowledgeSourceSpec[];
+    /** The declarative requirement specs that gate the loop. Reuses
+     *  `KnowledgeRequirementSpec` from `../knowledge` — `buildKnowledgeRequirements`
+     *  + `deriveSignals` consume these directly. */
+    requirements: KnowledgeRequirementSpec[];
+    /** Optional acquisition-loop config (goal + confidence gate + freshness). */
+    loop?: KnowledgeLoopConfig;
+}
+/**
+ * Which integrations the product enables, as data. `enabled` lists
+ * `@tangle-network/agent-integrations` catalog kinds the product connects
+ * (e.g. `['shurens', 'lead-crm', 'whatsapp']`); the integration hub resolves
+ * each to a connector. Strings, not connector objects — agent-app bakes no
+ * catalog value.
+ */
+interface AgentIntegrationsConfig {
+    /** Catalog kinds this product enables. */
+    enabled: string[];
+}
+/** UI capability flags, as data. */
+interface AgentUiConfig {
+    /** Whether the agent may emit generated UI (the `render_ui` / OpenUI side
+     *  channel). When false/omitted, the tool layer can omit/refuse the tool.
+     *  Default behavior decided by the consumer; omit to leave unset. */
+    generatedUi?: boolean;
+}
+/** Background-agent / delegated-loop capability, as data. */
+interface AgentDelegationConfig {
+    /** When true, the app's own agent may spawn `delegate_research` /
+     *  `delegate_code` loops that run to completion in their OWN sandbox and
+     *  return the artifact (the `../delegation` driven-loop MCP). Sandbox-path
+     *  ONLY — the browser/edge path ignores it. Wired via the existing
+     *  `buildDelegationMcpServer`; never reimplemented. */
+    enabled?: boolean;
+}
+/**
+ * The declarative domain surface of a Tangle agent product.
+ *
+ * A coding agent fills THIS object and nothing else to define a product's
+ * identity, proposal taxonomy, knowledge gate, integrations, UI capability, and
+ * model. Every field is DATA consumed by an agent-app module through its typed
+ * seam — no field is behavior. Author it through {@link defineAgentApp} for
+ * autocomplete and a single import.
+ */
+interface AgentAppConfig {
+    /** Who the agent is — name, persona, system-prompt fragments, disclaimers. */
+    identity: AgentIdentityConfig;
+    /** Proposal types + which are regulated/approval-gated. */
+    taxonomy: AgentTaxonomyConfig;
+    /** Knowledge sources, requirement specs (the loop gate), and loop config. */
+    knowledge: AgentKnowledgeConfig;
+    /** Enabled integration catalog kinds. */
+    integrations: AgentIntegrationsConfig;
+    /** UI capability flags. Optional. */
+    ui?: AgentUiConfig;
+    /** Background-agent / delegated-loop capability (sandbox path). Optional. */
+    delegation?: AgentDelegationConfig;
+    /** The resolved model config (`../runtime`'s `TangleModelConfig`). Omit to
+     *  resolve from env at boot via `resolveTangleModelConfig`. */
+    model?: TangleModelConfig;
+}
+/**
+ * Identity helper: returns its argument unchanged, but anchors inference so a
+ * coding agent authoring a config gets full autocomplete + type-checking from a
+ * single import. The canonical way to declare a product config:
+ *
+ * ```ts
+ * import { defineAgentApp } from '@tangle-network/agent-app/config'
+ *
+ * export const config = defineAgentApp({
+ *   identity: { name: 'WinFinance', persona: '…' },
+ *   taxonomy: { proposalTypes: ['propose_swap'], regulatedTypes: ['propose_swap'] },
+ *   knowledge: { sources: [], requirements: [] },
+ *   integrations: { enabled: ['shurens'] },
+ * })
+ * ```
+ */
+declare function defineAgentApp<const T extends AgentAppConfig>(config: T): T;
+/**
+ * Machine-readable JSON Schema (draft 2020-12) for {@link AgentAppConfig}.
+ *
+ * The schema FLOOR a non-TypeScript coding agent (or a config validator/UI) reads
+ * to know the shape without parsing the `.d.ts`. Kept in lockstep with the
+ * interfaces above by the config test, which asserts the documented fields are
+ * present. `KnowledgeRequirementSpec`'s full sub-shape is intentionally left
+ * `additionalProperties: true` here — its authoritative definition lives in
+ * `../knowledge`; this floor pins only the fields the config contract owns.
+ */
+declare const agentAppConfigJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://tangle.tools/schemas/agent-app-config.json";
+    readonly title: "AgentAppConfig";
+    readonly description: "The declarative domain surface of a Tangle agent product.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["identity", "taxonomy", "knowledge", "integrations"];
+    readonly properties: {
+        readonly identity: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["name", "persona"];
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Product/agent name.";
+                };
+                readonly persona: {
+                    readonly type: "string";
+                    readonly description: "One-paragraph persona — the system-prompt spine.";
+                };
+                readonly systemPromptFragments: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Verbatim system-prompt fragments appended after the persona, in order.";
+                };
+                readonly disclaimers: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Named disclaimers keyed by stable id; values are literal text.";
+                };
+            };
+        };
+        readonly taxonomy: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["proposalTypes", "regulatedTypes"];
+            readonly properties: {
+                readonly proposalTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Closed allow-list of proposal types the product can emit.";
+                };
+                readonly regulatedTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Subset of proposalTypes that is approval-gated (certified-human required).";
+                };
+            };
+        };
+        readonly knowledge: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["sources", "requirements"];
+            readonly properties: {
+                readonly sources: {
+                    readonly type: "array";
+                    readonly description: "Sources the acquisition loop may draw on.";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["uri"];
+                        readonly properties: {
+                            readonly uri: {
+                                readonly type: "string";
+                                readonly description: "Where the source lives (opaque to agent-app).";
+                            };
+                            readonly kind: {
+                                readonly type: "string";
+                                readonly description: "Optional source classifier (web/vault/regulation/…).";
+                            };
+                        };
+                    };
+                };
+                readonly requirements: {
+                    readonly type: "array";
+                    readonly description: "Declarative KnowledgeRequirementSpec[] (../knowledge) that gate the loop.";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                    };
+                };
+                readonly loop: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly description: "Acquisition-loop config.";
+                    readonly properties: {
+                        readonly goal: {
+                            readonly type: "string";
+                            readonly description: "Acquisition goal in natural language.";
+                        };
+                        readonly minConfidence: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                            readonly maximum: 1;
+                            readonly description: "Minimum aggregate confidence the loop must reach.";
+                        };
+                        readonly freshness: {
+                            readonly type: "string";
+                            readonly description: "How fresh acquired knowledge must be.";
+                        };
+                    };
+                };
+            };
+        };
+        readonly integrations: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["enabled"];
+            readonly properties: {
+                readonly enabled: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Enabled agent-integrations catalog kinds.";
+                };
+            };
+        };
+        readonly ui: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly description: "UI capability flags.";
+            readonly properties: {
+                readonly generatedUi: {
+                    readonly type: "boolean";
+                    readonly description: "Whether the agent may emit generated UI.";
+                };
+            };
+        };
+        readonly delegation: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly description: "Background-agent / delegated-loop capability (sandbox path).";
+            readonly properties: {
+                readonly enabled: {
+                    readonly type: "boolean";
+                    readonly description: "Whether the agent may spawn delegate_research/delegate_code loops.";
+                };
+            };
+        };
+        readonly model: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly description: "Resolved TangleModelConfig (../runtime). Omit to resolve from env.";
+            readonly required: readonly ["provider", "model", "apiKey", "baseUrl"];
+            readonly properties: {
+                readonly provider: {
+                    readonly type: "string";
+                    readonly enum: readonly ["openai-compat", "anthropic"];
+                };
+                readonly model: {
+                    readonly type: "string";
+                };
+                readonly apiKey: {
+                    readonly type: "string";
+                };
+                readonly baseUrl: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+};
+
+export { type AgentAppConfig, type AgentDelegationConfig, type AgentIdentityConfig, type AgentIntegrationsConfig, type AgentKnowledgeConfig, type AgentTaxonomyConfig, type AgentUiConfig, type KnowledgeLoopConfig, KnowledgeRequirementSpec, type KnowledgeSourceSpec, TangleModelConfig, agentAppConfigJsonSchema, defineAgentApp };

package/dist/config/index.js

@@ -0,0 +1,9 @@
+import {
+  agentAppConfigJsonSchema,
+  defineAgentApp
+} from "../chunk-5RV6CAHZ.js";
+export {
+  agentAppConfigJsonSchema,
+  defineAgentApp
+};
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

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

package/dist/crypto/index.d.ts

@@ -23,5 +23,40 @@ declare function createFieldCrypto(key: string | (() => string)): {
     encrypt(s: string): Promise<string>;
     decrypt(s: string): Promise<string>;
 };
+/**
+ * --- Passphrase-derived key path (PBKDF2 → AES-256-GCM CryptoKey) ---
+ *
+ * The `encryptAesGcm`/`decryptAesGcm` path takes a raw 64-char-hex key. Some
+ * products instead bind a SECRET STRING (not a hex key) and derive the AES key
+ * with PBKDF2 — and need a BINARY path (encrypting document bytes, not just
+ * strings). Both are exposed here so a product never hand-rolls WebCrypto.
+ *
+ * The derivation parameters (salt, iterations) are PARAMETERS — a product pins
+ * its own so the derived key bytes stay stable for data already at rest. The
+ * default salt/iterations match the historical tax-agent contract, but any
+ * product supplies its own via {@link DeriveKeyOptions}.
+ */
+interface DeriveKeyOptions {
+    /** PBKDF2 salt. A product MUST pin this — changing it changes the derived key
+     *  bytes and orphans every value already encrypted at rest. */
+    salt: Uint8Array | string;
+    /** PBKDF2 iteration count. Pin it for the same reason as `salt`. */
+    iterations: number;
+    /** PBKDF2 hash. Default `'SHA-256'`. */
+    hash?: 'SHA-256' | 'SHA-384' | 'SHA-512';
+}
+/** Derive an AES-256-GCM `CryptoKey` from a secret string via PBKDF2. The key is
+ *  non-extractable and usable only for encrypt/decrypt. */
+declare function deriveKey(secret: string, opts: DeriveKeyOptions): Promise<CryptoKey>;
+/** Encrypt `plaintext` under a derived `CryptoKey`. Returns base64(iv ‖ ct ‖ tag). */
+declare function encryptWithKey(plaintext: string, key: CryptoKey): Promise<string>;
+/** Decrypt a base64(iv ‖ ct ‖ tag) string under a derived `CryptoKey`. */
+declare function decryptWithKey(encoded: string, key: CryptoKey): Promise<string>;
+/** Encrypt binary data under a derived `CryptoKey`. Returns an ArrayBuffer:
+ *  12-byte IV ‖ ciphertext ‖ 16-byte GCM tag (same wire layout as the string
+ *  path, raw bytes instead of base64). */
+declare function encryptBytes(data: ArrayBuffer, key: CryptoKey): Promise<ArrayBuffer>;
+/** Decrypt binary data (IV ‖ ciphertext ‖ tag) under a derived `CryptoKey`. */
+declare function decryptBytes(data: ArrayBuffer, key: CryptoKey): Promise<ArrayBuffer>;
 
-export { createFieldCrypto, decodeHexKey, decryptAesGcm, encryptAesGcm };
+export { type DeriveKeyOptions, createFieldCrypto, decodeHexKey, decryptAesGcm, decryptBytes, decryptWithKey, deriveKey, encryptAesGcm, encryptBytes, encryptWithKey };

package/dist/crypto/index.js

@@ -2,12 +2,22 @@ import {
   createFieldCrypto,
   decodeHexKey,
   decryptAesGcm,
-  encryptAesGcm
-} from "../chunk-SIDR6BH3.js";
+  decryptBytes,
+  decryptWithKey,
+  deriveKey,
+  encryptAesGcm,
+  encryptBytes,
+  encryptWithKey
+} from "../chunk-ZJGY7OMZ.js";
 export {
   createFieldCrypto,
   decodeHexKey,
   decryptAesGcm,
-  encryptAesGcm
+  decryptBytes,
+  decryptWithKey,
+  deriveKey,
+  encryptAesGcm,
+  encryptBytes,
+  encryptWithKey
 };
 //# sourceMappingURL=index.js.map

package/dist/delegation/index.d.ts

@@ -46,5 +46,20 @@ interface BuildDelegationOptions {
  *   const mcp = { ...(delegation ? { [DELEGATION_MCP_SERVER_KEY]: delegation } : {}) }
  */
 declare function buildDelegationMcpServer(opts: BuildDelegationOptions): DelegationMcpServer | undefined;
+/**
+ * Config-driven wiring: returns the delegation MCP entry keyed under
+ * {@link DELEGATION_MCP_SERVER_KEY} when the product's `config.delegation.enabled`
+ * is true (and a platform key is available), else an empty object. Spread the
+ * result directly into the sandbox profile's `mcp` map — this is the seam
+ * `agent.config.delegation` flows through, so a coding agent toggles background
+ * agents/loops by flipping one boolean, never by wiring the MCP by hand.
+ *
+ *   const mcp = { ...rest, ...delegationMcpForConfig(config, { apiKey: env.TANGLE_API_KEY, forwardEnv: env }) }
+ */
+declare function delegationMcpForConfig(config: {
+    delegation?: {
+        enabled?: boolean;
+    };
+}, opts: BuildDelegationOptions): Record<string, DelegationMcpServer>;
 
-export { type BuildDelegationOptions, DELEGATION_MCP_SERVER_KEY, DELEGATION_TOOLS, type DelegationMcpServer, buildDelegationMcpServer };
+export { type BuildDelegationOptions, DELEGATION_MCP_SERVER_KEY, DELEGATION_TOOLS, type DelegationMcpServer, buildDelegationMcpServer, delegationMcpForConfig };

package/dist/delegation/index.js

@@ -1,11 +1,13 @@
 import {
   DELEGATION_MCP_SERVER_KEY,
   DELEGATION_TOOLS,
-  buildDelegationMcpServer
-} from "../chunk-7P6VIHI4.js";
+  buildDelegationMcpServer,
+  delegationMcpForConfig
+} from "../chunk-AQ2BOPOQ.js";
 export {
   DELEGATION_MCP_SERVER_KEY,
   DELEGATION_TOOLS,
-  buildDelegationMcpServer
+  buildDelegationMcpServer,
+  delegationMcpForConfig
 };
 //# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -1,13 +1,19 @@
 export { APP_TOOL_NAMES, AppToolMcpServer, AppToolName, AppToolRuntimeExecutor, AuthenticateOptions, BuildHttpMcpServerOptions, BuildMcpServerOptions, CapabilityTokenOptions, DEFAULT_APP_TOOL_PATHS, DEFAULT_HEADER_NAMES, DispatchOptions, HandleToolRequestOptions, OpenAIFunctionTool, RuntimeExecutorOptions, ToolAuthResult, ToolHeaderNames, ToolInputError, authenticateToolRequest, buildAppToolMcpServer, buildAppToolOpenAITools, buildHttpMcpServer, createAppToolRuntimeExecutor, createCapabilityToken, dispatchAppTool, handleAppToolRequest, isAppToolName, outcomeStatus, readToolArgs, verifyCapabilityToken } from './tools/index.js';
 export { A as AddCitationArgs, a as AddCitationResult, b as AppToolContext, c as AppToolHandlers, d as AppToolOutcome, e as AppToolProducedEvent, f as AppToolTaxonomy, R as RenderUiArgs, g as RenderUiResult, S as ScheduleFollowupArgs, h as ScheduleFollowupResult, i as SubmitProposalArgs, j as SubmitProposalResult } from './types-CeWor4bQ.js';
-export { BuildDelegationOptions, DELEGATION_MCP_SERVER_KEY, DELEGATION_TOOLS, DelegationMcpServer, buildDelegationMcpServer } from './delegation/index.js';
+export { BuildDelegationOptions, DELEGATION_MCP_SERVER_KEY, DELEGATION_TOOLS, DelegationMcpServer, buildDelegationMcpServer, delegationMcpForConfig } from './delegation/index.js';
 export { BrokerToken, BrokerTokenMinter, BrokerTokenProvider, BrokerTokenProviderOptions, ConsentUrlInput, buildConsentUrl, createBrokerTokenProvider } from './tangle/index.js';
-export { AppToolLoopOptions, DEFAULT_TANGLE_ROUTER_BASE_URL, LoopEvent, LoopToolCall, OpenAICompatStreamTurnOptions, OpenAIStreamChunk, ResolveModelOptions, StreamAppToolLoopOptions, StreamLoopYield, TangleModelConfig, ToolLoopResult, createOpenAICompatStreamTurn, resolveTangleModelConfig, runAppToolLoop, streamAppToolLoop, toLoopEvents } from './runtime/index.js';
+export { AppToolLoopOptions, LoopEvent, LoopToolCall, OpenAICompatStreamTurnOptions, OpenAIStreamChunk, StreamAppToolLoopOptions, StreamLoopYield, ToolLoopResult, createOpenAICompatStreamTurn, runAppToolLoop, streamAppToolLoop, toLoopEvents } from './runtime/index.js';
 export { createTokenRecallChecker, producedFromToolEvents } from './eval/index.js';
-export { KeyCrypto, KeyProvisioner, WorkspaceKeyManager, WorkspaceKeyManagerOptions, WorkspaceKeyRecord, WorkspaceKeyStore, WorkspaceModelKeyUsage, createWorkspaceKeyManager } from './billing/index.js';
-export { createFieldCrypto, decodeHexKey, decryptAesGcm, encryptAesGcm } from './crypto/index.js';
+export { KnowledgeRequirementSpec, KnowledgeSignal, KnowledgeStateAccessor, SatisfiedByRule, buildKnowledgeRequirements, deriveSignals } from './knowledge/index.js';
+export { CreateKnowledgeLoopDeps, KnowledgeCandidate, KnowledgeDecider, KnowledgeDeciderInput, KnowledgeDecision, KnowledgeGateVerdict, KnowledgeLoop, KnowledgeLoopDriver, createKnowledgeLoop, createReviewerDecider, reviewCandidate } from './knowledge-loop/index.js';
+export { AgentAppConfig, AgentDelegationConfig, AgentIdentityConfig, AgentIntegrationsConfig, AgentKnowledgeConfig, AgentTaxonomyConfig, AgentUiConfig, KnowledgeLoopConfig, KnowledgeSourceSpec, agentAppConfigJsonSchema, defineAgentApp } from './config/index.js';
+export { D1Like, D1PreparedLike, DrizzleColumnLike, DrizzleSqliteCoreLike, PRESET_MIGRATION_SQL, PRESET_TABLES, PresetBillingOptions, PresetKnowledgeAccessorOptions, PresetToolHandlerOptions, VaultKv, createD1KnowledgeStateAccessor, createPresetDrizzleSchema, createPresetFieldCrypto, createPresetToolHandlers, createPresetWorkspaceKeyManager, createPresetWorkspaceKeyStore } from './preset-cloudflare/index.js';
+export { KeyCrypto, KeyProvisioner, PlanLimit, PlatformBalanceInfo, PlatformBalanceManager, PlatformBalanceManagerOptions, PlatformBillingClient, PlatformIdentity, PlatformProductUsage, SharedBillingState, WorkspaceKeyManager, WorkspaceKeyManagerOptions, WorkspaceKeyRecord, WorkspaceKeyStore, WorkspaceModelKeyUsage, createPlatformBalanceManager, createWorkspaceKeyManager } from './billing/index.js';
+export { DeriveKeyOptions, createFieldCrypto, decodeHexKey, decryptAesGcm, decryptBytes, decryptWithKey, deriveKey, encryptAesGcm, encryptBytes, encryptWithKey } from './crypto/index.js';
 export { JsonRecord, PersistedChatMessageForTurn, ResolvedChatTurn, StreamEvent, asRecord, asString, buildUserTextParts, encodeEvent, finalizeAssistantParts, getPartKey, mergePersistedPart, messageHasTurnId, normalizeClientTurnId, normalizePersistedPart, normalizeTime, normalizeToolEvent, resolveChatTurn, resolveToolId, resolveToolName } from './stream/index.js';
 export { HubExecClient, HubExecClientOptions, HubExecErrorCode, HubExecResult, HubInvokeDeps, HubInvokeInput, HubInvokeOutcome, ParsedIntegrationAction, invokeIntegrationHub, resolveIntegrationAction } from './integrations/index.js';
 export { JsonObject, KvLike, RateLimitResult, RequestContext, SecurityHeaderOptions, addSecurityHeaders, checkRateLimit, extractRequestContext, parseJsonObjectBody, requireString } from './web/index.js';
 export { redactForIngestion } from './redact/index.js';
 export { CompletionRequirement, CompletionVerdict, CorrectnessChecker, ProducedState, RuntimeEventLike, SatisfiedBy, TaskGold, createLlmCorrectnessChecker, extractProducedState, verifyCompletion, weightedComposite } from '@tangle-network/agent-eval';
+export { D as DEFAULT_TANGLE_ROUTER_BASE_URL, R as ResolveModelOptions, T as TangleModelConfig, r as resolveTangleModelConfig } from './model-BOP69mVu.js';
+import '@tangle-network/agent-knowledge';

package/dist/index.js

@@ -1,3 +1,32 @@
+import {
+  agentAppConfigJsonSchema,
+  defineAgentApp
+} from "./chunk-5RV6CAHZ.js";
+import {
+  PRESET_MIGRATION_SQL,
+  PRESET_TABLES,
+  createD1KnowledgeStateAccessor,
+  createPresetDrizzleSchema,
+  createPresetFieldCrypto,
+  createPresetToolHandlers,
+  createPresetWorkspaceKeyManager,
+  createPresetWorkspaceKeyStore
+} from "./chunk-EZXN67KE.js";
+import {
+  createPlatformBalanceManager,
+  createWorkspaceKeyManager
+} from "./chunk-EAJSWUU5.js";
+import {
+  createFieldCrypto,
+  decodeHexKey,
+  decryptAesGcm,
+  decryptBytes,
+  decryptWithKey,
+  deriveKey,
+  encryptAesGcm,
+  encryptBytes,
+  encryptWithKey
+} from "./chunk-ZJGY7OMZ.js";
 import {
   asRecord,
   asString,
@@ -51,8 +80,9 @@ import {
 import {
   DELEGATION_MCP_SERVER_KEY,
   DELEGATION_TOOLS,
-  buildDelegationMcpServer
-} from "./chunk-7P6VIHI4.js";
+  buildDelegationMcpServer,
+  delegationMcpForConfig
+} from "./chunk-AQ2BOPOQ.js";
 import {
   buildConsentUrl,
   createBrokerTokenProvider
@@ -74,14 +104,14 @@ import {
   weightedComposite
 } from "./chunk-4NXVI7PW.js";
 import {
-  createWorkspaceKeyManager
-} from "./chunk-45MYQ3GD.js";
+  buildKnowledgeRequirements,
+  deriveSignals
+} from "./chunk-ZXNXAQAH.js";
 import {
-  createFieldCrypto,
-  decodeHexKey,
-  decryptAesGcm,
-  encryptAesGcm
-} from "./chunk-SIDR6BH3.js";
+  createKnowledgeLoop,
+  createReviewerDecider,
+  reviewCandidate
+} from "./chunk-EEPJGZJW.js";
 export {
   APP_TOOL_NAMES,
   DEFAULT_APP_TOOL_PATHS,
@@ -90,8 +120,11 @@ export {
   DELEGATION_MCP_SERVER_KEY,
   DELEGATION_TOOLS,
   HubExecClient,
+  PRESET_MIGRATION_SQL,
+  PRESET_TABLES,
   ToolInputError,
   addSecurityHeaders,
+  agentAppConfigJsonSchema,
   asRecord,
   asString,
   authenticateToolRequest,
@@ -100,21 +133,39 @@ export {
   buildConsentUrl,
   buildDelegationMcpServer,
   buildHttpMcpServer,
+  buildKnowledgeRequirements,
   buildUserTextParts,
   checkRateLimit,
   createAppToolRuntimeExecutor,
   createBrokerTokenProvider,
   createCapabilityToken,
+  createD1KnowledgeStateAccessor,
   createFieldCrypto,
+  createKnowledgeLoop,
   createLlmCorrectnessChecker,
   createOpenAICompatStreamTurn,
+  createPlatformBalanceManager,
+  createPresetDrizzleSchema,
+  createPresetFieldCrypto,
+  createPresetToolHandlers,
+  createPresetWorkspaceKeyManager,
+  createPresetWorkspaceKeyStore,
+  createReviewerDecider,
   createTokenRecallChecker,
   createWorkspaceKeyManager,
   decodeHexKey,
   decryptAesGcm,
+  decryptBytes,
+  decryptWithKey,
+  defineAgentApp,
+  delegationMcpForConfig,
+  deriveKey,
+  deriveSignals,
   dispatchAppTool,
   encodeEvent,
   encryptAesGcm,
+  encryptBytes,
+  encryptWithKey,
   extractProducedState,
   extractRequestContext,
   finalizeAssistantParts,
@@ -139,6 +190,7 @@ export {
   resolveTangleModelConfig,
   resolveToolId,
   resolveToolName,
+  reviewCandidate,
   runAppToolLoop,
   streamAppToolLoop,
   toLoopEvents,