@tangle-network/agent-app 0.43.55 → 0.43.57

package/dist/redact/index.d.ts

@@ -33,6 +33,7 @@ interface RedactionPattern {
  *  `patterns` options rather than forking this module (the seam that lets a
  *  product add e.g. a credit-card matcher without a local copy). */
 declare const DEFAULT_REDACTION_PATTERNS: readonly RedactionPattern[];
+/** Define options to customize sensitive data redaction patterns and key names for ingestion */
 interface RedactForIngestionOptions {
     /** Extra patterns appended to {@link DEFAULT_REDACTION_PATTERNS} for the
      *  string-level scrub (e.g. credit-card). Additive — defaults still apply. */
@@ -91,9 +92,11 @@ type RedactedDocSegment = {
     kind: string;
     cipher: string;
 };
+/** Define a document composed of multiple redacted content segments */
 interface RedactedDocument {
     segments: RedactedDocSegment[];
 }
+/** Define options to encrypt text and specify patterns for redacting sensitive document content */
 interface BuildRedactedDocumentOptions {
     /** Encrypt one original span value. Wire it to `agent-app/crypto`
      *  (`encryptWithKey` / `createFieldCrypto`). The cipher is what's stored. */
@@ -108,6 +111,7 @@ interface BuildRedactedDocumentOptions {
  * {@link revealSpan}.
  */
 declare function buildRedactedDocument(text: string, options: BuildRedactedDocumentOptions): Promise<RedactedDocument>;
+/** Define options to decrypt, authorize, and audit the reveal of a span segment */
 interface RevealSpanOptions {
     /** Decrypt a span cipher. Wire to `agent-app/crypto` (`decryptWithKey`). */
     decrypt: (cipher: string) => string | Promise<string>;
@@ -122,6 +126,7 @@ interface RevealSpanOptions {
         kind: string;
     }) => void | Promise<void>;
 }
+/** Describe the outcome of a reveal operation including success status, value, and failure reason */
 interface RevealResult {
     ok: boolean;
     value?: string;

package/dist/redact/index.js

@@ -5,7 +5,7 @@ import {
   maskSpans,
   redactForIngestion,
   revealSpan
-} from "../chunk-5RMIUJDI.js";
+} from "../chunk-FKCB5FTD.js";
 export {
   DEFAULT_REDACTION_PATTERNS,
   buildRedactedDocument,

package/dist/{roles-BC1n4t37.d.ts → roles-B4nU3jDi.d.ts}

@@ -15,19 +15,29 @@
  * per-workspace role into the one effective workspace role a request runs at.
  */
 declare const WORKSPACE_ROLES: readonly ["viewer", "editor", "admin", "owner"];
+/** Resolve the union type of all possible workspace role string literals from WORKSPACE_ROLES array */
 type WorkspaceRole = typeof WORKSPACE_ROLES[number];
+/** Define the list of roles that can be assigned within a workspace */
 declare const ASSIGNABLE_WORKSPACE_ROLES: readonly ["viewer", "editor", "admin"];
+/** Resolve the set of roles that can be assigned within a workspace */
 type AssignableWorkspaceRole = typeof ASSIGNABLE_WORKSPACE_ROLES[number];
+/** Define the set of fixed roles available within an organization */
 declare const ORGANIZATION_ROLES: readonly ["owner", "admin", "member", "billing"];
+/** Resolve a role string from the predefined list of organization roles */
 type OrganizationRole = typeof ORGANIZATION_ROLES[number];
+/** Define access levels for workspace collaboration as either read or write */
 type WorkspaceCollaborationAccess = 'read' | 'write';
+/** Define user roles available within a sandbox workspace environment */
 type SandboxWorkspaceRole = 'owner' | 'admin' | 'developer' | 'viewer';
+/** Map workspace roles to their corresponding hierarchical rank values */
 declare const WORKSPACE_ROLE_RANK: Record<WorkspaceRole, number>;
+/** Map organization roles to their hierarchical rank for permission and access control purposes */
 declare const ORGANIZATION_ROLE_RANK: Record<OrganizationRole, number>;
 /** True when `actual` is at least `minimum` on the workspace ladder. */
 declare function hasWorkspaceRole(actual: WorkspaceRole, minimum: WorkspaceRole): boolean;
 /** True when `actual` is at least `minimum` on the organization ladder. */
 declare function hasOrganizationRole(actual: OrganizationRole, minimum: OrganizationRole): boolean;
+/** Determine if a value is a valid assignable workspace role among viewer, editor, or admin */
 declare function isAssignableWorkspaceRole(value: unknown): value is AssignableWorkspaceRole;
 /** Org owners and admins are workspace owners across the whole org. */
 declare function organizationRoleGrantsWorkspaceOwner(role: OrganizationRole | string | null | undefined): boolean;
@@ -43,7 +53,9 @@ declare function resolveWorkspaceRole(organizationRole: OrganizationRole | strin
  * their own rank (an admin cannot demote another admin or an owner).
  */
 declare function canManageWorkspaceMemberRole(actorRole: WorkspaceRole, targetRole: WorkspaceRole): boolean;
+/** Map a workspace role to the corresponding collaboration access level */
 declare function workspaceRoleToCollaborationAccess(role: WorkspaceRole): WorkspaceCollaborationAccess;
+/** Map a workspace role to its corresponding sandbox workspace role */
 declare function workspaceRoleToSandboxRole(role: WorkspaceRole): SandboxWorkspaceRole;
 
 export { type AssignableWorkspaceRole as A, type OrganizationRole as O, type SandboxWorkspaceRole as S, WORKSPACE_ROLES as W, ASSIGNABLE_WORKSPACE_ROLES as a, ORGANIZATION_ROLES as b, ORGANIZATION_ROLE_RANK as c, WORKSPACE_ROLE_RANK as d, type WorkspaceCollaborationAccess as e, type WorkspaceRole as f, canManageWorkspaceMemberRole as g, hasOrganizationRole as h, hasWorkspaceRole as i, isAssignableWorkspaceRole as j, workspaceRoleToSandboxRole as k, organizationRoleGrantsWorkspaceOwner as o, resolveWorkspaceRole as r, workspaceRoleToCollaborationAccess as w };

package/dist/run/index.d.ts

@@ -19,11 +19,14 @@ import '@tangle-network/agent-interface';
  * thunk, so a router-only app never resolves `@tangle-network/sandbox`.
  */
 
+/** Define execution mode as either router or sandbox */
 type ExecutionMode = 'router' | 'sandbox';
 /** The router pseudo-harness — the absence of a sandbox backend. Not a member
  *  of `KNOWN_HARNESSES`; callers may pass it explicitly instead of null. */
 declare const ROUTER_HARNESS: "router";
+/** Provide a type alias for the ROUTER_HARNESS constant to enable consistent router harness usage */
 type RouterHarness = typeof ROUTER_HARNESS;
+/** Resolve a ProfileHarness as a Harness, RouterHarness, null, or undefined value */
 type ProfileHarness = Harness | RouterHarness | null | undefined;
 /**
  * Infer the execution mode from a profile's harness. Absent / null / 'router'

package/dist/run/index.js

@@ -1,6 +1,6 @@
 import {
   KNOWN_HARNESSES
-} from "../chunk-MCJSS6SM.js";
+} from "../chunk-CQZSAR77.js";
 
 // src/run/index.ts
 var ROUTER_HARNESS = "router";

package/dist/run/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/run/index.ts"],"sourcesContent":["/**\n * Execution-mode dispatch — the shell entry that infers *how* to run an agent\n * from its profile's harness, so a product hands over one profile and the\n * framework routes to the router tool loop or a sandbox without separate wiring.\n *\n * The discriminator is the harness: absent / null / 'router' => the router tool\n * agent (`@tangle-network/agent-app/runtime`); any member of `KNOWN_HARNESSES`\n * (opencode, claude-code, …) => a sandbox (`@tangle-network/agent-app/sandbox`).\n * `KNOWN_HARNESSES` is exactly the set of sandbox backends; the *absence* of a\n * harness is the router signal.\n *\n * `runAgent` owns the inference + routing; the two branch runners are injected,\n * because their inputs and event shapes legitimately differ (the router loop\n * yields `LoopEvent`s, the sandbox yields its own events). A product supplies a\n * `router`/`sandbox` thunk and can lazy-import the sandbox driver inside its own\n * thunk, so a router-only app never resolves `@tangle-network/sandbox`.\n */\n\nimport { KNOWN_HARNESSES, type Harness } from '../harness/index'\n\nexport type ExecutionMode = 'router' | 'sandbox'\n\n/** The router pseudo-harness — the absence of a sandbox backend. Not a member\n *  of `KNOWN_HARNESSES`; callers may pass it explicitly instead of null. */\nexport const ROUTER_HARNESS = 'router' as const\nexport type RouterHarness = typeof ROUTER_HARNESS\n\nexport type ProfileHarness = Harness | RouterHarness | null | undefined\n\n/**\n * Infer the execution mode from a profile's harness. Absent / null / 'router'\n * => 'router'; a known sandbox harness => 'sandbox'. An unrecognized non-null\n * string is treated as a sandbox backend (the box installs all harnesses, so an\n * unknown id is a sandbox the runtime resolves, not a router) — callers that\n * want strictness can validate against `KNOWN_HARNESSES` first.\n */\nexport function resolveExecutionMode(harness: ProfileHarness): ExecutionMode {\n  if (harness == null || harness === ROUTER_HARNESS) return 'router'\n  return 'sandbox'\n}\n\n/** True when `harness` names a sandbox backend the SDK knows about. */\nexport function isKnownSandboxHarness(harness: ProfileHarness): harness is Harness {\n  return harness != null && harness !== ROUTER_HARNESS && (KNOWN_HARNESSES as readonly string[]).includes(harness)\n}\n\n/**\n * The superset the dispatch reads: the SDK `AgentProfile` plus the harness\n * discriminator. Intentionally pins only `harness` — the rest of the profile is\n * carried opaquely so this module stays free of the SDK type (router-only apps\n * import it without `@tangle-network/sandbox`).\n */\nexport interface ShellProfile {\n  harness?: ProfileHarness\n}\n\n/** Execution mode for a profile — `harness` omitted/null => router. */\nexport function executionModeForProfile(profile: ShellProfile): ExecutionMode {\n  return resolveExecutionMode(profile.harness)\n}\n\n/** The two branch runners. Each returns (or resolves to) an async iterable of\n *  the product's own event type — the shapes differ, so the product owns them.\n *  A `sandbox` thunk can `await import('@tangle-network/agent-app/sandbox')`\n *  internally so the SDK is pulled only on the sandbox path. */\nexport interface RunAgentBranches<T> {\n  router: () => AsyncIterable<T> | Promise<AsyncIterable<T>>\n  sandbox: () => AsyncIterable<T> | Promise<AsyncIterable<T>>\n}\n\n/**\n * Route a turn to the branch the harness selects and stream its events through.\n * The shell does the inference; the product supplies how each branch runs. The\n * unselected branch's thunk is never invoked — so its dependencies (e.g. the\n * sandbox SDK) are never loaded on the other path.\n */\nexport async function* runAgent<T>(\n  harness: ProfileHarness,\n  branches: RunAgentBranches<T>,\n): AsyncGenerator<T> {\n  const mode = resolveExecutionMode(harness)\n  const source = mode === 'sandbox' ? branches.sandbox() : branches.router()\n  const iterable = await source\n  for await (const event of iterable) yield event\n}\n"],"mappings":";;;;;AAwBO,IAAM,iBAAiB;AAYvB,SAAS,qBAAqB,SAAwC;AAC3E,MAAI,WAAW,QAAQ,YAAY,eAAgB,QAAO;AAC1D,SAAO;AACT;AAGO,SAAS,sBAAsB,SAA6C;AACjF,SAAO,WAAW,QAAQ,YAAY,kBAAmB,gBAAsC,SAAS,OAAO;AACjH;AAaO,SAAS,wBAAwB,SAAsC;AAC5E,SAAO,qBAAqB,QAAQ,OAAO;AAC7C;AAiBA,gBAAuB,SACrB,SACA,UACmB;AACnB,QAAM,OAAO,qBAAqB,OAAO;AACzC,QAAM,SAAS,SAAS,YAAY,SAAS,QAAQ,IAAI,SAAS,OAAO;AACzE,QAAM,WAAW,MAAM;AACvB,mBAAiB,SAAS,SAAU,OAAM;AAC5C;","names":[]}
+{"version":3,"sources":["../../src/run/index.ts"],"sourcesContent":["/**\n * Execution-mode dispatch — the shell entry that infers *how* to run an agent\n * from its profile's harness, so a product hands over one profile and the\n * framework routes to the router tool loop or a sandbox without separate wiring.\n *\n * The discriminator is the harness: absent / null / 'router' => the router tool\n * agent (`@tangle-network/agent-app/runtime`); any member of `KNOWN_HARNESSES`\n * (opencode, claude-code, …) => a sandbox (`@tangle-network/agent-app/sandbox`).\n * `KNOWN_HARNESSES` is exactly the set of sandbox backends; the *absence* of a\n * harness is the router signal.\n *\n * `runAgent` owns the inference + routing; the two branch runners are injected,\n * because their inputs and event shapes legitimately differ (the router loop\n * yields `LoopEvent`s, the sandbox yields its own events). A product supplies a\n * `router`/`sandbox` thunk and can lazy-import the sandbox driver inside its own\n * thunk, so a router-only app never resolves `@tangle-network/sandbox`.\n */\n\nimport { KNOWN_HARNESSES, type Harness } from '../harness/index'\n\n/** Define execution mode as either router or sandbox */\nexport type ExecutionMode = 'router' | 'sandbox'\n\n/** The router pseudo-harness — the absence of a sandbox backend. Not a member\n *  of `KNOWN_HARNESSES`; callers may pass it explicitly instead of null. */\nexport const ROUTER_HARNESS = 'router' as const\n/** Provide a type alias for the ROUTER_HARNESS constant to enable consistent router harness usage */\nexport type RouterHarness = typeof ROUTER_HARNESS\n\n/** Resolve a ProfileHarness as a Harness, RouterHarness, null, or undefined value */\nexport type ProfileHarness = Harness | RouterHarness | null | undefined\n\n/**\n * Infer the execution mode from a profile's harness. Absent / null / 'router'\n * => 'router'; a known sandbox harness => 'sandbox'. An unrecognized non-null\n * string is treated as a sandbox backend (the box installs all harnesses, so an\n * unknown id is a sandbox the runtime resolves, not a router) — callers that\n * want strictness can validate against `KNOWN_HARNESSES` first.\n */\nexport function resolveExecutionMode(harness: ProfileHarness): ExecutionMode {\n  if (harness == null || harness === ROUTER_HARNESS) return 'router'\n  return 'sandbox'\n}\n\n/** True when `harness` names a sandbox backend the SDK knows about. */\nexport function isKnownSandboxHarness(harness: ProfileHarness): harness is Harness {\n  return harness != null && harness !== ROUTER_HARNESS && (KNOWN_HARNESSES as readonly string[]).includes(harness)\n}\n\n/**\n * The superset the dispatch reads: the SDK `AgentProfile` plus the harness\n * discriminator. Intentionally pins only `harness` — the rest of the profile is\n * carried opaquely so this module stays free of the SDK type (router-only apps\n * import it without `@tangle-network/sandbox`).\n */\nexport interface ShellProfile {\n  harness?: ProfileHarness\n}\n\n/** Execution mode for a profile — `harness` omitted/null => router. */\nexport function executionModeForProfile(profile: ShellProfile): ExecutionMode {\n  return resolveExecutionMode(profile.harness)\n}\n\n/** The two branch runners. Each returns (or resolves to) an async iterable of\n *  the product's own event type — the shapes differ, so the product owns them.\n *  A `sandbox` thunk can `await import('@tangle-network/agent-app/sandbox')`\n *  internally so the SDK is pulled only on the sandbox path. */\nexport interface RunAgentBranches<T> {\n  router: () => AsyncIterable<T> | Promise<AsyncIterable<T>>\n  sandbox: () => AsyncIterable<T> | Promise<AsyncIterable<T>>\n}\n\n/**\n * Route a turn to the branch the harness selects and stream its events through.\n * The shell does the inference; the product supplies how each branch runs. The\n * unselected branch's thunk is never invoked — so its dependencies (e.g. the\n * sandbox SDK) are never loaded on the other path.\n */\nexport async function* runAgent<T>(\n  harness: ProfileHarness,\n  branches: RunAgentBranches<T>,\n): AsyncGenerator<T> {\n  const mode = resolveExecutionMode(harness)\n  const source = mode === 'sandbox' ? branches.sandbox() : branches.router()\n  const iterable = await source\n  for await (const event of iterable) yield event\n}\n"],"mappings":";;;;;AAyBO,IAAM,iBAAiB;AAcvB,SAAS,qBAAqB,SAAwC;AAC3E,MAAI,WAAW,QAAQ,YAAY,eAAgB,QAAO;AAC1D,SAAO;AACT;AAGO,SAAS,sBAAsB,SAA6C;AACjF,SAAO,WAAW,QAAQ,YAAY,kBAAmB,gBAAsC,SAAS,OAAO;AACjH;AAaO,SAAS,wBAAwB,SAAsC;AAC5E,SAAO,qBAAqB,QAAQ,OAAO;AAC7C;AAiBA,gBAAuB,SACrB,SACA,UACmB;AACnB,QAAM,OAAO,qBAAqB,OAAO;AACzC,QAAM,SAAS,SAAS,YAAY,SAAS,QAAQ,IAAI,SAAS,OAAO;AACzE,QAAM,WAAW,MAAM;AACvB,mBAAiB,SAAS,SAAU,OAAM;AAC5C;","names":[]}

package/dist/runtime/index.d.ts

@@ -1,12 +1,12 @@
 export { CatalogModel, ModelCatalog, RouterModel, __resetCatalogCache, buildCatalog, fetchModelCatalog, normalizeModelId } from '../catalog/index.js';
-export { C as CreateTangleRouterModelConfigOptions, D as DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR, a as DEFAULT_TANGLE_ROUTER_BASE_URL, R as ResolveModelOptions, b as ResolveTangleDevOrUserKeyOptions, c as ResolveUserTangleExecutionKeyForUserOptions, d as ResolveUserTangleExecutionKeyOptions, e as ResolvedTangleExecutionKey, T as TangleBillingEnforcementOptions, f as TangleExecutionEnvironment, g as TangleExecutionKeyError, h as TangleExecutionKeyErrorCode, i as TangleExecutionKeyHttpError, j as TangleExecutionKeySource, k as TangleModelConfig, l as createTangleRouterModelConfig, m as isTangleBillingEnforcementDisabled, n as isTangleExecutionKeyError, r as resolveTangleDevOrUserKey, o as resolveTangleExecutionEnvironment, p as resolveTangleModelConfig, q as resolveUserTangleExecutionKey, s as resolveUserTangleExecutionKeyForUser, t as tangleExecutionKeyHttpError, u as trimOrNull } from '../model-dF2h4xT9.js';
+export { C as CreateTangleRouterModelConfigOptions, D as DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR, a as DEFAULT_TANGLE_ROUTER_BASE_URL, R as ResolveModelOptions, b as ResolveTangleDevOrUserKeyOptions, c as ResolveUserTangleExecutionKeyForUserOptions, d as ResolveUserTangleExecutionKeyOptions, e as ResolvedTangleExecutionKey, T as TangleBillingEnforcementOptions, f as TangleExecutionEnvironment, g as TangleExecutionKeyError, h as TangleExecutionKeyErrorCode, i as TangleExecutionKeyHttpError, j as TangleExecutionKeySource, k as TangleModelConfig, l as createTangleRouterModelConfig, m as isTangleBillingEnforcementDisabled, n as isTangleExecutionKeyError, r as resolveTangleDevOrUserKey, o as resolveTangleExecutionEnvironment, p as resolveTangleModelConfig, q as resolveUserTangleExecutionKey, s as resolveUserTangleExecutionKeyForUser, t as tangleExecutionKeyHttpError, u as trimOrNull } from '../model-DmdkIteM.js';
 import * as _tangle_network_agent_runtime from '@tangle-network/agent-runtime';
 import { ToolLoopMessage, ToolLoopResult, StreamToolLoopYield, ToolLoopCall } from '@tangle-network/agent-runtime';
 export { RunToolLoopOptions as AppToolLoopOptions, ToolLoopAssistantToolCall as LoopAssistantToolCall, ToolLoopMessage as LoopMessage, ToolLoopCall as LoopToolCall, StreamToolLoopOptions as StreamAppToolLoopOptions, StreamToolLoopYield as StreamLoopYield, ToolLoopEvent, ToolLoopResult, ToolLoopStopReason, runToolLoop as runAppToolLoop, streamToolLoop as streamAppToolLoop } from '@tangle-network/agent-runtime';
-import { c as AppToolContext, h as AppToolProducedEvent, i as AppToolTaxonomy, e as AppToolHandlers, g as AppToolOutcome } from '../types-BEOvc_ue.js';
+import { c as AppToolContext, h as AppToolProducedEvent, i as AppToolTaxonomy, e as AppToolHandlers, g as AppToolOutcome } from '../types-CBRyqijY.js';
 import { CertifiedProfile } from '@tangle-network/agent-runtime/intelligence';
-import { A as AppToolMcpServer } from '../mcp-BHfIoGLW.js';
-import '../auth-DuptSkWh.js';
+import { A as AppToolMcpServer } from '../mcp-BjPqQ-3C.js';
+import '../auth-_FU8w01b.js';
 
 /**
  * Events the app's OpenAI-compat stream adapter ({@link toLoopEvents}) yields.
@@ -89,6 +89,7 @@ interface OpenAIStreamChunk {
  * throwing). Works for the Tangle Router, tcloud, or any OpenAI-compat source.
  */
 declare function toLoopEvents(chunks: AsyncIterable<OpenAIStreamChunk>): AsyncIterable<LoopEvent>;
+/** Define options for configuring an OpenAI-compatible streaming chat turn including API details and tools */
 interface OpenAICompatStreamTurnOptions {
     /** OpenAI-compat base URL (e.g. the Tangle Router `https://router.tangle.tools/v1`). */
     baseUrl: string;
@@ -166,6 +167,7 @@ interface ResolvedAgentProfile {
     systemPrompt: string;
     extraTools: unknown[];
 }
+/** Define options for creating an agent runtime including model config and optional profile transformation */
 interface CreateAgentRuntimeOptions {
     /** The model endpoint the turns stream from. */
     model: AgentRuntimeModelConfig;
@@ -197,6 +199,7 @@ interface CreateAgentRuntimeOptions {
     /** Which non-app tool names are executable here. Required if {@link executeOtherTool} is set. */
     isOtherExecutableTool?: (toolName: string) => boolean;
 }
+/** Define options for configuring a single agent turn including context, prior messages, prompts, and event handlers */
 interface AgentTurnOptions {
     /** The trusted per-turn context (who/where the turn runs as). */
     ctx: AppToolContext;
@@ -210,6 +213,7 @@ interface AgentTurnOptions {
     /** Fires at the real side-effect site for each produced proposal/artifact. */
     onProduced?: (event: AppToolProducedEvent) => void;
 }
+/** Resolve and stream tool execution loops with final results and intermediate events for agent runtime */
 interface AgentRuntime {
     /** Run the bounded tool loop to completion; resolve with final text + every
      *  executed tool outcome. */
@@ -251,6 +255,7 @@ declare function createAgentRuntime(opts: CreateAgentRuntimeOptions): AgentRunti
  * `createAgentRuntime` core does not (it only consumes the generic transform).
  */
 
+/** Define configuration options for delivering certified artifacts to a specified tenant target */
 interface CertifiedDeliveryConfig {
     /** The tenant target whose certified artifacts to deliver (the agent id). */
     target: string;
@@ -263,6 +268,7 @@ interface CertifiedDeliveryConfig {
     /** fetch impl (tests / non-global-fetch runtimes). */
     fetchImpl?: typeof fetch;
 }
+/** Resolve and manage certified profiles with refresh and composition capabilities */
 interface CertifiedDelivery {
     /** The `composeProfile` transform to pass to `createAgentRuntime`. Applies the
      *  cached certified profile to the base surfaces; refreshes on the cadence. */
@@ -350,6 +356,7 @@ declare function defineSurfaceKind<TCtx>(opts: {
     kind: string;
     build: (ctx: TCtx) => SurfaceOverlay | Promise<SurfaceOverlay>;
 }): SurfaceKindDefinition<TCtx>;
+/** Resolve and build the overlay for a given surface kind within a turn context */
 interface SurfaceRegistry {
     /** Build the overlay for one turn. Throws on an unknown kind — an unknown
      *  surface is a routing bug (client and server registries drifted), and

package/dist/runtime/index.js

@@ -8,7 +8,7 @@ import {
   runToolLoop,
   streamToolLoop,
   toLoopEvents
-} from "../chunk-CCRVDLV3.js";
+} from "../chunk-JWBZ74TW.js";
 import {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,
@@ -23,14 +23,14 @@ import {
   resolveUserTangleExecutionKeyForUser,
   tangleExecutionKeyHttpError,
   trimOrNull
-} from "../chunk-7W5XSTUF.js";
-import "../chunk-MFRCM32T.js";
+} from "../chunk-JML7WKWU.js";
+import "../chunk-7CTIUCQ4.js";
 import {
   __resetCatalogCache,
   buildCatalog,
   fetchModelCatalog,
   normalizeModelId
-} from "../chunk-GUSCYE3S.js";
+} from "../chunk-TQOFR6XY.js";
 export {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,