@isomorph.ai/app-sdk 1.36.0 → 1.36.2

package/README.md

@@ -452,10 +452,10 @@ await runtimeSecrets.delete(`supplier-key/${ctx.user.id}`);
 
 - Names match `^[A-Za-z0-9][A-Za-z0-9/_+=.@-]{0,199}$`; values are strings up to 64 KB.
 - Each is one Secrets Manager secret in the app's own cell, under `ISOMORPH_RUNTIME_SECRETS_PREFIX` (the app's secret path plus `runtime/`, in `ISOMORPH_RUNTIME_SECRETS_REGION`); Provision sets both. The calls are signed as the runtime's own role, which may use only this app's runtime secrets. Secrets the builder set stay read-only.
-- `delete` removes the secret at once, with no recovery window, so the same name can be saved again straight away.
+- `delete` removes the secret with no recovery window. Secrets Manager finishes deleting it within seconds; until then `get` returns null, and a `put` of the same name waits for the deletion to finish (up to about 25 seconds) before saving.
 - Each one costs $0.40 a month while it exists.
 
-(1.36.0; data plane ADR 0090)
+(1.36.0, 1.36.1; data plane ADR 0090)
 
 ## Running and rollout
 

package/dist/runtime.js

@@ -237,18 +237,31 @@ export class Runs {
         const interrupted = expired.filter(run => !active.has(run.id));
         for (const run of interrupted) {
             const exhausted = run.attempt >= run.max_attempts;
-            await this.table().update({ status: exhausted ? 'failed' : 'queued', error: exhausted ? 'the worker was interrupted and no attempts remain' : run.error, lease_until: null, updated_at: now.toISOString() }).eq('id', run.id).eq('status', 'running');
+            const status = run.cancel_requested ? 'cancelled' : exhausted ? 'failed' : 'queued';
+            const { data } = await this.table().update({ status, error: status === 'failed' ? 'the worker was interrupted and no attempts remain' : run.error, lease_until: null, updated_at: now.toISOString() }).eq('id', run.id).eq('status', 'running').eq('cancel_requested', run.cancel_requested).select('id').maybeSingle();
+            // Cancellation may have arrived between reading the expired lease and
+            // writing its retry. It wins that race without leaving another attempt.
+            if (!data && !run.cancel_requested)
+                await this.table().update({ status: 'cancelled', lease_until: null, updated_at: now.toISOString() }).eq('id', run.id).eq('status', 'running').eq('cancel_requested', true);
         }
         return interrupted.length;
     }
     /** Claims the oldest queued run by a conditional update; null when the queue is empty or another worker won. */
     async claim(now) {
-        const { data: queued } = await this.table().select('id, attempt').eq('status', 'queued').order('created_at').limit(1);
-        const next = queued[0];
-        if (!next)
-            return null;
-        const { data } = await this.table().update({ status: 'running', attempt: next.attempt + 1, lease_until: new Date(now.getTime() + LEASE_MS).toISOString(), updated_at: now.toISOString() }).eq('id', next.id).eq('status', 'queued').select('*').maybeSingle();
-        return data;
+        while (true) {
+            const { data: queued } = await this.table().select('id, attempt, cancel_requested').eq('status', 'queued').order('created_at').limit(1);
+            const next = queued[0];
+            if (!next)
+                return null;
+            if (next.cancel_requested) {
+                const { data } = await this.table().update({ status: 'cancelled', lease_until: null, updated_at: now.toISOString() }).eq('id', next.id).eq('status', 'queued').eq('cancel_requested', true).select('id').maybeSingle();
+                if (!data)
+                    return null;
+                continue;
+            }
+            const { data } = await this.table().update({ status: 'running', attempt: next.attempt + 1, lease_until: new Date(now.getTime() + LEASE_MS).toISOString(), updated_at: now.toISOString() }).eq('id', next.id).eq('status', 'queued').eq('cancel_requested', false).select('*').maybeSingle();
+            return data;
+        }
     }
     async progress(id, percent, note) {
         await this.table().update({ progress: Math.max(0, Math.min(100, Math.round(percent))), ...(note === undefined ? {} : { note }), lease_until: new Date(Date.now() + LEASE_MS).toISOString(), updated_at: new Date().toISOString() }).eq('id', id);
@@ -261,8 +274,16 @@ export class Runs {
     async finish(run, outcome) {
         const retry = outcome.error !== undefined && !outcome.cancelled && run.attempt < run.max_attempts;
         const status = outcome.cancelled ? 'cancelled' : outcome.error === undefined ? 'succeeded' : retry ? 'queued' : 'failed';
-        await this.table().update({ status, result: outcome.result ?? null, error: outcome.error ?? null, progress: status === 'succeeded' ? 100 : run.progress, lease_until: null, updated_at: new Date().toISOString() }).eq('id', run.id).eq('status', 'running');
-        return status;
+        const now = new Date().toISOString();
+        if (!outcome.cancelled) {
+            const { data } = await this.table().update({ status, result: outcome.result ?? null, error: outcome.error ?? null, progress: status === 'succeeded' ? 100 : run.progress, lease_until: null, updated_at: now }).eq('id', run.id).eq('status', 'running').eq('cancel_requested', false).select('id').maybeSingle();
+            if (data)
+                return status;
+        }
+        // The handler may throw after the user cancels. A cancelled run is
+        // terminal even when that failure would otherwise be retried.
+        await this.table().update({ status: 'cancelled', result: null, error: null, lease_until: null, updated_at: now }).eq('id', run.id).eq('status', 'running').eq('cancel_requested', true);
+        return 'cancelled';
     }
 }
 export class Runtime {

package/dist/secrets.d.ts

@@ -1,6 +1,8 @@
 export interface RuntimeSecretsOptions {
     env?: NodeJS.ProcessEnv;
     fetch?: typeof fetch;
+    /** The waits before put tries again to create a secret whose deletion Secrets Manager is still finishing. */
+    retryDelaysMs?: readonly number[];
 }
 /** Where a runtime secret lives; throws, before any call, for a bad name or an app without runtime secrets. */
 export declare function runtimeSecretLocation(name: string, env?: NodeJS.ProcessEnv): {
@@ -10,8 +12,11 @@ export declare function runtimeSecretLocation(name: string, env?: NodeJS.Process
 export declare const runtimeSecrets: {
     /** Saves `value` under `name`, creating the secret the first time. */
     put(name: string, value: string, options?: RuntimeSecretsOptions): Promise<void>;
-    /** The value saved under `name`, or null when there is none. */
+    /** The value saved under `name`, or null when there is none or it is being deleted. */
     get(name: string, options?: RuntimeSecretsOptions): Promise<string | null>;
-    /** Deletes the secret at once, so the same name can be saved again straight away; a missing one is already deleted. */
+    /**
+     * Deletes the secret with no recovery window; a missing one is already deleted. Secrets Manager finishes the
+     * deletion within seconds, and `put` waits for it before saving the same name again.
+     */
     delete(name: string, options?: RuntimeSecretsOptions): Promise<void>;
 };

package/dist/secrets.js

@@ -6,9 +6,14 @@
 // The calls are signed as the runtime's own role, as the computer use tool's
 // are (ADR 0078); no AWS SDK client is added.
 import { randomUUID } from 'node:crypto';
+import { setTimeout as sleep } from 'node:timers/promises';
 import { runtimeCredentials, signedJsonPost } from './aws.js';
 const NAME = /^[A-Za-z0-9][A-Za-z0-9/_+=.@-]{0,199}$/;
 const MAX_VALUE_BYTES = 64 * 1024;
+// A deleted secret stays "marked for deletion" for some seconds: reads and writes are refused and its name
+// cannot be created again until Secrets Manager finishes deleting it.
+const DELETION_RETRY_DELAYS_MS = [1_000, 2_000, 4_000, 8_000, 10_000];
+const BEING_DELETED = /(marked|scheduled) for deletion/;
 /** Where a runtime secret lives; throws, before any call, for a bad name or an app without runtime secrets. */
 export function runtimeSecretLocation(name, env = process.env) {
     if (typeof name !== 'string' || !NAME.test(name))
@@ -27,12 +32,14 @@ function secretsManager(name, { env = process.env, fetch }) {
             ...transport, headers: { 'content-type': 'application/x-amz-json-1.1', 'x-amz-target': `secretsmanager.${action}` },
         });
         if (status === 200)
-            return { missing: false, body };
+            return { outcome: 'done', body };
         const answer = body;
         const type = typeof answer?.__type === 'string' ? answer.__type.replace(/^.*#/, '').replace(/:.*$/, '') : '';
-        if (type === 'ResourceNotFoundException')
-            return { missing: true, body };
         const message = answer?.message ?? answer?.Message;
+        if (type === 'ResourceNotFoundException')
+            return { outcome: 'missing', body };
+        if (type === 'InvalidRequestException' && typeof message === 'string' && BEING_DELETED.test(message))
+            return { outcome: 'deleting', body };
         throw new Error(`Secrets Manager refused ${action} on the runtime secret ${name} (${status}${type ? ` ${type}` : ''}${typeof message === 'string' ? `: ${message}` : ''}).`);
     };
     return { secretId, send };
@@ -45,16 +52,28 @@ export const runtimeSecrets = {
             throw new Error(`The runtime secret ${name} must be a string of at most 64 KB.`);
         // Secrets Manager wants each new version's idempotency token from a caller that is not an AWS SDK.
         const saved = await send('PutSecretValue', { SecretId: secretId, SecretString: value, ClientRequestToken: randomUUID() });
-        if (saved.missing)
-            await send('CreateSecret', { Name: secretId, SecretString: value, ClientRequestToken: randomUUID() });
+        if (saved.outcome === 'done')
+            return;
+        const delays = options.retryDelaysMs ?? DELETION_RETRY_DELAYS_MS;
+        for (let attempt = 0;; attempt++) {
+            const created = await send('CreateSecret', { Name: secretId, SecretString: value, ClientRequestToken: randomUUID() });
+            if (created.outcome === 'done')
+                return;
+            if (attempt >= delays.length)
+                throw new Error(`The runtime secret ${name} is still being deleted; save it again in a minute.`);
+            await sleep(delays[attempt]);
+        }
     },
-    /** The value saved under `name`, or null when there is none. */
+    /** The value saved under `name`, or null when there is none or it is being deleted. */
     async get(name, options = {}) {
         const { secretId, send } = secretsManager(name, options);
         const read = await send('GetSecretValue', { SecretId: secretId });
-        return read.missing ? null : read.body.SecretString ?? null;
+        return read.outcome === 'done' ? read.body.SecretString ?? null : null;
     },
-    /** Deletes the secret at once, so the same name can be saved again straight away; a missing one is already deleted. */
+    /**
+     * Deletes the secret with no recovery window; a missing one is already deleted. Secrets Manager finishes the
+     * deletion within seconds, and `put` waits for it before saving the same name again.
+     */
     async delete(name, options = {}) {
         const { secretId, send } = secretsManager(name, options);
         await send('DeleteSecret', { SecretId: secretId, ForceDeleteWithoutRecovery: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isomorph.ai/app-sdk",
-  "version": "1.36.0",
+  "version": "1.36.2",
   "type": "module",
   "repository": {
     "type": "git",