@tangle-network/agent-app 0.48.4 → 0.49.2

package/dist/chat-routes/native-completion.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Exact terminal observation for a native Sandbox execution that another
+ * request already admitted. This module never sends a prompt, calls
+ * `driveTurn`, or cancels a run.
+ */
+import type { SandboxInstance } from '@tangle-network/sandbox';
+import type { ChatTurnUsage } from './turn-routes';
+export interface NativeCompletionReceipt {
+    state: 'completed' | 'failed';
+    text: string;
+    parts: Array<Record<string, unknown>>;
+    /** An empty object is an unknown usage receipt, never a measured zero. */
+    usage: ChatTurnUsage;
+    servedModel?: string;
+    servedProvider?: string;
+    servedSource?: 'request' | 'environment' | 'profile';
+    error?: string;
+    completedTurnIds: string[];
+}
+export interface NativeCompletionAdmission {
+    executionId: string;
+    state: 'open' | 'closed';
+    admittedTurnIds: readonly string[];
+    ownerLeaseUntil: Date | number;
+    updatedAt?: Date | number;
+    closedAt?: Date | number | null;
+}
+/** Product persistence for the one admission that authorizes this observer. */
+export interface NativeCompletionAdmissionStore {
+    read(executionId: string): Promise<NativeCompletionAdmission | null>;
+    renew(executionId: string, now: Date): Promise<NativeCompletionAdmission | null>;
+    closeExpired(executionId: string, now: Date): Promise<NativeCompletionAdmission | null>;
+}
+/** The official Sandbox reads needed for exact native completion observation. */
+export type NativeCompletionSessionSource = Pick<SandboxInstance, 'findCompletedTurn' | 'session'>;
+export interface NativeCompletionObservationOptions {
+    /** Null when the product cannot currently resolve the admitted Sandbox. */
+    source: NativeCompletionSessionSource | null;
+    admissionStore: NativeCompletionAdmissionStore;
+    executionId: string;
+    sessionId: string;
+    turnId: string;
+    registeredAt: number;
+    absentDispatchDeadlineMs?: number;
+    receiptDeadlineMs?: number;
+    now?: number;
+}
+export type NativeCompletionObservation = {
+    state: 'running';
+} | {
+    state: 'completed';
+    receipt: NativeCompletionReceipt;
+} | {
+    state: 'failed';
+    receipt: NativeCompletionReceipt;
+};
+/** One exact turn receipt before an admission's ordered aggregate. */
+export interface NativeCompletionTurnReceipt {
+    turnId: string;
+    state: 'completed' | 'failed';
+    text: string;
+    parts: Array<Record<string, unknown>>;
+    usage: ChatTurnUsage;
+    servedModel?: string;
+    servedProvider?: string;
+    servedSource?: 'request' | 'environment' | 'profile';
+    error?: string;
+}
+/** Assemble admitted exact receipts in dispatch order. Missing usage stays unknown. */
+export declare function aggregateNativeCompletionReceipts(turns: readonly NativeCompletionTurnReceipt[]): NativeCompletionReceipt;
+/**
+ * Observe only the turns admitted under `executionId`. Transport failures throw
+ * so the durable owner retries. A missing or partial terminal record remains
+ * `running` until the configured deadline; it never starts another run.
+ */
+export declare function observeNativeCompletion(options: NativeCompletionObservationOptions): Promise<NativeCompletionObservation>;

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

@@ -244,6 +244,17 @@ export interface ChatTurnProduceArgs<TContext> {
      *    resolved without a usable id.
      *  - a string — the row id, for `contextGate`, `beforeTurn`, and `produce`. */
     userMessageId?: string | null;
+    /**
+     * Transfer completion ownership to a product-owned durable runner. The
+     * product MUST first register that runner durably, then await this callback
+     * before dispatching native execution. Once it resolves, this route remains
+     * a live event projector only: it no longer writes or settles the assistant
+     * transcript, lifecycle hooks, lock, or replay-buffer status.
+     *
+     * Optional for source compatibility with synthetic producers. Every
+     * `createChatTurnRoutes` invocation supplies it before `produce` runs.
+     */
+    handoffCompletion?: () => Promise<void>;
 }
 /** One event as it crosses the route: the producer's own vocabulary, or an
  *  injected keepalive. Same shape the engine forwards verbatim.

package/dist/{chunk-3SIQ4CDA.js → chunk-7S24DNVP.js}

@@ -1547,8 +1547,11 @@ async function listStopped(client, name) {
 }
 async function deleteBox(box) {
   try {
-    await box.delete();
+    const acknowledgement = await box.delete({ until: "removed" });
     livenessVerifiedAt.delete(box.id);
+    if (acknowledgement.removal === "pending") {
+      return fail(new Error(`sandbox ${box.id} removal is still pending; retry replacement after removal completes`));
+    }
     return ok(void 0);
   } catch (err) {
     return fail(err);
@@ -2010,7 +2013,11 @@ async function provisionWorkspaceSandbox(shell, options) {
   let replacementRequested = false;
   const resources = shell.resources ?? DEFAULT_SANDBOX_RESOURCES;
   const resumeTimeout = shell.provisionTimeoutMs ?? DEFAULT_PROVISION_TIMEOUT_MS;
-  const existing = await listRunning(client, name);
+  let existing = await listRunning(client, name);
+  if (forceNew && existing.succeeded && !existing.value) {
+    existing = await listStopped(client, name);
+  }
+  if (forceNew && !existing.succeeded) throw existing.error;
   if (existing.succeeded && existing.value) {
     const found = existing.value;
     if (forceNew) {
@@ -2837,4 +2844,4 @@ export {
   isTerminalPromptEvent,
   detectInteractiveQuestion
 };
-//# sourceMappingURL=chunk-3SIQ4CDA.js.map
+//# sourceMappingURL=chunk-7S24DNVP.js.map