@tangle-network/agent-app 0.47.5 → 0.47.7

package/dist/billing/identity-bound.d.ts

@@ -29,6 +29,8 @@ export interface DurableWorkspaceKeyRecord {
     sourceKeyFingerprint: string;
     /** The persisted name used to recover a remote create after a crash. Null only for pre-name rows. */
     name: string | null;
+    /** The persisted retry identity for the remote create. Absent on legacy rows without a persisted create identity. */
+    idempotencyKey?: string | null;
     keyId: string;
     keyEncrypted: string;
     budgetUsd: number;
@@ -48,9 +50,21 @@ type DurableWorkspaceKeyCreateResult = Awaited<ReturnType<KeyProvisioner['create
     budgetRemaining?: number;
     expiresAt?: string | null;
 };
+/** The exact request identity that must be reused when recovering a create. */
+export interface DurableWorkspaceKeyCreateInput {
+    name: string;
+    product: string;
+    budgetUsd: number;
+    expiresAt: string;
+    /** Stable across process restarts for one persisted provisioning row. */
+    idempotencyKey: string;
+}
 /** The remote operations required by the durable manager. */
 export interface DurableWorkspaceKeyProvisioner {
-    createKey(input: Parameters<KeyProvisioner['createKey']>[0]): Promise<DurableWorkspaceKeyCreateResult>;
+    /** True only when replay returns the original child for the persisted request identity. */
+    supportsIdempotentCreate?: true;
+    /** Create one child key. Non-idempotent providers recover through stable-name discovery only. */
+    createKey(input: DurableWorkspaceKeyCreateInput): Promise<DurableWorkspaceKeyCreateResult>;
     getKey(id: string): Promise<{
         budgetUsd?: number | null;
         budgetSpent?: number;
@@ -66,6 +80,22 @@ export interface DurableWorkspaceKeyProvisioner {
         id: string;
     }>>;
 }
+/** Optional compare-and-set lifecycle writes for stores that support fencing. */
+export interface DurableWorkspaceKeyConditionalWrites {
+    /** Return false when the row was no longer provisioning. */
+    markProvisioningRemote(input: {
+        id: string;
+        keyId: string;
+    }): Promise<boolean>;
+    /** Return false when the row was no longer provisioning. */
+    markActive(input: {
+        id: string;
+        keyId: string;
+        keyEncrypted: string;
+        expiresAt: Date;
+        budgetUsd: number;
+    }): Promise<boolean>;
+}
 /** Persistence operations for identity-bound key lifecycle state. */
 export interface DurableWorkspaceKeyStore {
     /** Return the active row for this exact product scope. */
@@ -87,7 +117,12 @@ export interface DurableWorkspaceKeyStore {
         expiresAt: Date;
         budgetUsd: number;
     }): Promise<void>;
-    /** Keep a failed cleanup visible and schedule a later retry. */
+    /**
+     * Optional fenced writes. The manager uses false to compensate a stale
+     * creator. Stores without this field retain the pre-fence behavior.
+     */
+    conditionalWrites?: DurableWorkspaceKeyConditionalWrites;
+    /** Keep a failed cleanup visible and schedule a later retry. Terminal rows are immutable. */
     markRevocationPending(input: {
         id: string;
         error?: string | null;
@@ -139,13 +174,22 @@ export interface DurableWorkspaceKeyManager {
     }): Promise<WorkspaceRuntimeKey>;
     /** Read usage without returning the child secret. */
     getUsage(identity: WorkspaceKeyIdentity): Promise<WorkspaceKeyUsage | null>;
-    /** Retry due cleanup rows. A supplied owner/workspace limits the retry to its scope. */
-    retryPendingRevocations(scope?: Pick<WorkspaceKeyIdentity, 'ownerUserId' | 'workspaceId'>): Promise<number>;
+    /**
+     * Retry due cleanup rows. A supplied owner/workspace limits the retry to its
+     * scope. Empty provisioning rows also require the full identity so a retry
+     * can use the original source binding safely.
+     */
+    retryPendingRevocations(scope?: Pick<WorkspaceKeyIdentity, 'ownerUserId' | 'workspaceId'>, identity?: WorkspaceKeyIdentity): Promise<number>;
 }
 /** Configuration for {@link createIdentityBoundWorkspaceKeyManager}. */
 export interface DurableWorkspaceKeyManagerOptions {
     store: DurableWorkspaceKeyStore;
     provisioner: DurableWorkspaceKeyProvisioner;
+    /**
+     * Control-plane client for historical get/revoke/list operations. Use this
+     * when the source credential can rotate or disappear. It never mints keys.
+     */
+    recoveryProvisioner?: Pick<DurableWorkspaceKeyProvisioner, 'getKey' | 'revokeKey' | 'findCreatedKeys'>;
     crypto: KeyCrypto;
     /** Product partition. Products must use separate values. */
     product: WorkspaceKeyProduct;

package/dist/billing/index.d.ts

@@ -239,4 +239,4 @@ export interface PlatformBalanceManager<Plan extends string> {
 export declare function createPlatformBalanceManager<Plan extends string>(opts: PlatformBalanceManagerOptions<Plan>): PlatformBalanceManager<Plan>;
 /** Create a workspace key manager that handles key provisioning and budget tracking */
 export declare function createWorkspaceKeyManager(opts: WorkspaceKeyManagerOptions): WorkspaceKeyManager;
-export { createIdentityBoundWorkspaceKeyManager, type DurableWorkspaceKeyManager, type DurableWorkspaceKeyManagerOptions, type DurableWorkspaceKeyProvisioner, type DurableWorkspaceKeyProvisioningRecord, type DurableWorkspaceKeyRecord, type DurableWorkspaceKeyScope, type DurableWorkspaceKeyStore, type WorkspaceKeyIdentity, type WorkspaceKeyProduct, type WorkspaceKeyStatus, type WorkspaceKeyUsage, type WorkspaceRuntimeKey, } from './identity-bound';
+export { createIdentityBoundWorkspaceKeyManager, type DurableWorkspaceKeyManager, type DurableWorkspaceKeyManagerOptions, type DurableWorkspaceKeyCreateInput, type DurableWorkspaceKeyConditionalWrites, type DurableWorkspaceKeyProvisioner, type DurableWorkspaceKeyProvisioningRecord, type DurableWorkspaceKeyRecord, type DurableWorkspaceKeyScope, type DurableWorkspaceKeyStore, type WorkspaceKeyIdentity, type WorkspaceKeyProduct, type WorkspaceKeyStatus, type WorkspaceKeyUsage, type WorkspaceRuntimeKey, } from './identity-bound';

package/dist/billing/index.js

@@ -3,7 +3,7 @@ import {
   createPlatformBalanceManager,
   createTcloudKeyProvisioner,
   createWorkspaceKeyManager
-} from "../chunk-TS2ZIB53.js";
+} from "../chunk-4ZJYNI53.js";
 export {
   createIdentityBoundWorkspaceKeyManager,
   createPlatformBalanceManager,

package/dist/chat-routes/index.d.ts

@@ -13,6 +13,7 @@ export * from './turn-routes';
 export * from './gateway-adapter';
 export * from './stale-turn-lock';
 export * from './sandbox-producer';
+export * from './protected-runtime-producer';
 export * from './model-failover-stream';
 export * from './draft-persistence';
 export * from './detached-turn';

package/dist/chat-routes/index.js

@@ -49,6 +49,9 @@ import "../chunk-KBJL6LIW.js";
 import "../chunk-TX6S7XXU.js";
 import "../chunk-UGWQLQDS.js";
 import "../chunk-S5SRJJQG.js";
+import {
+  ProtectedModelSettlementError
+} from "../chunk-KHRIPDW5.js";
 import "../chunk-JML7WKWU.js";
 import {
   assistantRowIdForTurn,
@@ -1037,6 +1040,184 @@ ${diagnostic.userMessage}` : diagnostic.userMessage;
   };
 }
 
+// src/chat-routes/protected-runtime-producer.ts
+import { createExecutor, streamAgentTurn } from "@tangle-network/agent-runtime/kernel";
+import {
+  runProtectedAgentCandidateModelGrant
+} from "@tangle-network/agent-runtime/candidate-execution";
+function createProtectedRuntimeChatProducer(options) {
+  if (!Number.isSafeInteger(options.maxToolCalls) || options.maxToolCalls < 0) {
+    throw new Error("maxToolCalls must be a non-negative integer");
+  }
+  options = {
+    ...options,
+    grant: { ...options.grant, resolve: structuredClone(options.grant.resolve), reserve: structuredClone(options.grant.reserve) },
+    tools: options.tools.map((tool) => ({ ...tool, inputSchema: structuredClone(tool.inputSchema) })),
+    priorMessages: options.priorMessages ? structuredClone(options.priorMessages) : void 0
+  };
+  const tools = new Map(options.tools.map((tool) => [tool.name, tool]));
+  if (tools.size !== options.tools.length) throw new Error("Duplicate protected tool name");
+  const profile = structuredClone(options.profile);
+  let toolCalls = 0;
+  let usage = {};
+  let started = false;
+  let model;
+  let budgetEnforced = false;
+  let toolTokens;
+  async function* events() {
+    if (started) throw new Error("A protected chat producer can only execute once");
+    started = true;
+    const controller = new AbortController();
+    options.signal?.throwIfAborted();
+    if (Date.now() >= options.grant.deadlineAtMs) throw new Error("Protected execution deadline expired");
+    const signal = AbortSignal.any([
+      controller.signal,
+      AbortSignal.timeout(Math.max(1, options.grant.deadlineAtMs - Date.now())),
+      ...options.signal ? [options.signal] : []
+    ]);
+    const channel = new TransformStream();
+    const writer = channel.writable.getWriter();
+    const reader = channel.readable.getReader();
+    const emit = (event) => writer.write(event);
+    const execution = runProtectedAgentCandidateModelGrant({
+      ...options.grant,
+      port: {
+        resolve: (input) => options.grant.port.resolve(input),
+        reserveGrant: (input) => options.grant.port.reserveGrant(input),
+        activateGrant: (input) => options.grant.port.activateGrant(input),
+        // Runtime settles failed executions before rethrowing. Retain that receipt too.
+        settleGrant: async (input) => {
+          let auditError;
+          const settlement = await options.grant.port.settleGrant(input).catch((error) => {
+            if (!(error instanceof ProtectedModelSettlementError)) throw error;
+            auditError = error;
+            return error.settlement;
+          });
+          usage = {
+            inputTokens: settlement.calls.reduce((sum, call) => sum + call.accountedInputTokens, 0),
+            outputTokens: settlement.calls.reduce((sum, call) => sum + call.outputTokens, 0),
+            reasoningTokens: settlement.calls.reduce((sum, call) => sum + call.reasoningTokens, 0),
+            costUsd: settlement.calls.reduce((sum, call) => sum + call.costUsdNanos, 0) / 1e9
+          };
+          budgetEnforced = settlement.usageWithinLimits;
+          if (!budgetEnforced) throw new Error("Provider settlement exceeded execution limits");
+          if (auditError) throw auditError;
+          return settlement;
+        }
+      },
+      execute: async ({ activation, resolved }) => {
+        signal.throwIfAborted();
+        if (Date.now() >= options.grant.deadlineAtMs) throw new Error("Protected execution deadline expired");
+        model = resolved.model;
+        if (resolved.provider !== "anthropic" || resolved.reasoningEffort !== "none") {
+          throw new Error("Protected chat currently requires Anthropic without reasoning");
+        }
+        toolTokens = 0;
+        const apiKey = activation.env.OPENAI_API_KEY;
+        const baseUrl = activation.env.OPENAI_BASE_URL;
+        if (!apiKey || !baseUrl) throw new Error("Protected Router activation is missing");
+        const factory = createExecutor({
+          backend: "router-tools",
+          routerBaseUrl: baseUrl,
+          routerKey: apiKey,
+          tools: options.tools.map((tool) => ({
+            type: "function",
+            function: { name: tool.name, description: tool.description, parameters: tool.inputSchema }
+          })),
+          ...options.priorMessages?.length ? { initialMessages: options.priorMessages } : {},
+          executeToolCall: async (name, args) => {
+            signal.throwIfAborted();
+            const tool = tools.get(name);
+            if (!tool) throw new Error("Tool is not authorized for this execution");
+            if (toolCalls >= options.maxToolCalls) {
+              controller.abort(new Error("Execution tool-call limit reached"));
+              signal.throwIfAborted();
+            }
+            toolCalls += 1;
+            const id = `tool-${toolCalls}`;
+            await emit({ type: "tool_call", data: { id, name, arguments: args } });
+            try {
+              const result = await tool.run(args, { signal });
+              await emit({ type: "tool_result", data: { id, name, output: result } });
+              return JSON.stringify(result);
+            } catch (error) {
+              const message = error instanceof Error ? error.message : "Tool failed";
+              await emit({ type: "tool_result", data: { id, name, error: message } });
+              throw error;
+            }
+          }
+        });
+        let completed = false;
+        for await (const event of streamAgentTurn(
+          { kind: "executor", factory, profile },
+          { prompt: options.prompt },
+          {
+            signal,
+            callId: options.grant.reserve.executionId,
+            timeoutMs: Math.max(1, options.grant.deadlineAtMs - Date.now())
+          }
+        )) {
+          if (event.type === "text_delta" || event.type === "reasoning_delta") {
+            await emit({ type: "message.part.updated", data: {
+              part: { id: event.type, type: event.type === "text_delta" ? "text" : "reasoning" },
+              delta: event.text
+            } });
+          }
+          if (event.type === "final") {
+            if (event.status !== "completed") throw new Error(`Protected execution ${event.status}`);
+            completed = true;
+            await emit({ type: "result", data: { finalText: event.text } });
+          }
+        }
+        if (!completed) throw new Error("Protected execution ended without a terminal result");
+      }
+    }).then(async () => {
+      await writer.close();
+    }).catch((error) => writer.abort(error));
+    try {
+      for (; ; ) {
+        const next = await reader.read();
+        if (next.done) break;
+        yield next.value;
+      }
+      await execution;
+    } finally {
+      controller.abort();
+      await reader.cancel().catch(() => void 0);
+      await execution;
+      reader.releaseLock();
+      writer.releaseLock();
+    }
+  }
+  const producer = createSandboxChatProducer({ events: events(), model: profile.model?.default });
+  return {
+    ...producer,
+    stream: (async function* () {
+      let failure;
+      for await (const event of producer.stream) {
+        if (event.type === "error") failure = event;
+        else yield event;
+      }
+      if (usage.inputTokens !== void 0 && usage.outputTokens !== void 0 && usage.costUsd !== void 0) {
+        yield { type: "usage", usage: {
+          promptTokens: usage.inputTokens,
+          completionTokens: usage.outputTokens,
+          providerCostUsd: usage.costUsd,
+          reasoningTokens: usage.reasoningTokens,
+          toolTokens,
+          toolCallCount: toolCalls,
+          budgetEnforced
+        } };
+      }
+      if (failure) yield failure;
+    })(),
+    get model() {
+      return model ?? profile.model?.default;
+    },
+    usage: () => ({ ...usage })
+  };
+}
+
 // src/chat-routes/detached-turn.ts
 var TERMINAL_ERROR_TYPES = /* @__PURE__ */ new Set(["error", "session.run.failed"]);
 function errorMessageOf(ev) {
@@ -2583,6 +2764,7 @@ export {
   createAtomicAttachmentWriter,
   createAttachmentUploadRoute,
   createChatTurnRoutes,
+  createProtectedRuntimeChatProducer,
   createSandboxChatProducer,
   createSandboxFileIndexRoute,
   createUploadRoute,