@the-open-engine/zeroshot 6.33.0 → 6.34.0

package/lib/hosted-target/zero-cloud-v1-adapter.d.cts

@@ -10,4 +10,5 @@ export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
     terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
     limits(signal?: AbortSignal): Promise<CapsuleLimits>;
     access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+    installRuntime(capsuleId: string, runtime: unknown, accessToken: string, signal?: AbortSignal): Promise<void>;
 }

package/lib/hosted-target/zero-cloud-v1-adapter.d.mts

@@ -10,4 +10,5 @@ export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
     terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
     limits(signal?: AbortSignal): Promise<CapsuleLimits>;
     access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+    installRuntime(capsuleId: string, runtime: unknown, accessToken: string, signal?: AbortSignal): Promise<void>;
 }

package/lib/hosted-target/zero-cloud-v1-adapter.d.ts

@@ -10,4 +10,5 @@ export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
     terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
     limits(signal?: AbortSignal): Promise<CapsuleLimits>;
     access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+    installRuntime(capsuleId: string, runtime: unknown, accessToken: string, signal?: AbortSignal): Promise<void>;
 }

package/lib/hosted-target/zero-cloud-v1-adapter.mjs

@@ -1,22 +1,14 @@
 import { IDEMPOTENCY_KEY_PATTERN, MAX_RESPONSE_BYTES } from './bounds.mjs';
-import { TargetAdapterError, TargetAuthError, TargetProtocolError, TargetTransportError, } from './errors.mjs';
+import { TargetProtocolError } from './errors.mjs';
 import { DefaultRetryPolicy } from './retry.mjs';
 import { assertCapsule, assertCapsuleAccess, assertCapsuleLimits, assertCapsuleListPage, } from './response-validation.mjs';
 import { readBoundedResponseJson } from '../target/bounded-response.mjs';
-import { throwCapsuleServerError } from './capsule-error-response.mjs';
 import { validateAccessUrl } from './access-url.mjs';
 import { withTargetRetry } from './retry-executor.mjs';
-import { requestUrl, } from './adapter-request.mjs';
-const DEFAULT_TRANSPORT = {
-    fetch(url, init) {
-        return globalThis.fetch(url, init);
-    },
-};
+import { installRuntime as installOpaqueRuntime } from './runtime-install.mjs';
+import { assertCapsuleResponseStatus } from './response-status.mjs';
+import { createAdapterRequester, } from './adapter-request.mjs';
 const DEFAULT_CLOCK = { now: () => Date.now() };
-function throwIfAborted(signal) {
-    if (signal?.aborted)
-        throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
-}
 function validOpaque(value, field) {
     if (value.length === 0 || value.length > 1024)
         throw new TargetProtocolError(`${field} is invalid`);
@@ -27,16 +19,14 @@ function jsonRequest(body) {
 export class ZeroCloudV1TargetAdapter {
     #descriptor;
     #organizationId;
-    #tokenProvider;
-    #transport;
+    #request;
     #clock;
     #retryPolicy;
     constructor(options) {
         this.#descriptor = options.descriptor;
         this.#organizationId = options.organization.id;
         validOpaque(this.#organizationId, 'organization id');
-        this.#tokenProvider = options.tokenProvider;
-        this.#transport = options.transport ?? DEFAULT_TRANSPORT;
+        this.#request = createAdapterRequester(options.descriptor, options.tokenProvider, options.transport);
         this.#clock = options.clock ?? DEFAULT_CLOCK;
         this.#retryPolicy = options.retryPolicy ?? new DefaultRetryPolicy();
     }
@@ -106,11 +96,33 @@ export class ZeroCloudV1TargetAdapter {
         validateAccessUrl(result.websocketUrl, capsuleId, this.#descriptor);
         return result;
     }
+    async installRuntime(capsuleId, runtime, accessToken, signal) {
+        const descriptor = this.#descriptor.credentialInstall;
+        if (descriptor === null) {
+            throw new TargetProtocolError('Target does not advertise runtime installation');
+        }
+        await installOpaqueRuntime({
+            capsuleId,
+            runtime,
+            accessToken,
+            descriptor,
+            ...(signal === undefined ? {} : { signal }),
+            clock: this.#clock,
+            retryPolicy: this.#retryPolicy,
+            request: (method, path, requestSignal, body, token) => this.#request({
+                method,
+                path,
+                signal: requestSignal,
+                request: { body },
+                accessToken: token,
+            }),
+        });
+    }
     #execute(...args) {
         return Promise.resolve().then(() => this.#executeExpanded(args));
     }
     #executeExpanded(args) {
-        const [operation, method, template, values, expectedStatus, validate, signal, request = {},] = args;
+        const [operation, method, template, values, expectedStatus, validate, signal, request = {}] = args;
         let path;
         try {
             path = template.expand(values);
@@ -119,60 +131,17 @@ export class ZeroCloudV1TargetAdapter {
             throw new TargetProtocolError('Capsule route expansion is unsafe');
         }
         return withTargetRetry(operation, async () => {
-            const response = await this.#request(method, path, signal, request);
-            if (response.status >= 300 && response.status < 400) {
-                await response.body?.cancel().catch(() => undefined);
-                throw new TargetProtocolError('Capsule redirects are forbidden');
-            }
-            if (response.status !== expectedStatus) {
-                if (response.status >= 200 && response.status < 300) {
-                    await response.body?.cancel().catch(() => undefined);
-                    throw new TargetProtocolError('Target returned an unexpected success status');
-                }
-                await throwCapsuleServerError(response, (errorResponse) => this.#readJson(errorResponse), this.#clock);
-            }
+            const response = await this.#request({
+                method,
+                path,
+                signal,
+                request,
+                accessToken: undefined,
+            });
+            await assertCapsuleResponseStatus(response, expectedStatus, (errorResponse) => this.#readJson(errorResponse), this.#clock);
             return validate(await this.#readJson(response));
         }, signal, { clock: this.#clock, policy: this.#retryPolicy });
     }
-    async #request(method, path, signal, request) {
-        throwIfAborted(signal);
-        const url = requestUrl(path, this.#descriptor);
-        let token;
-        try {
-            token = await this.#tokenProvider.getAccessToken(signal);
-        }
-        catch {
-            throw new TargetAuthError('Target access authorization failed');
-        }
-        const init = {
-            method,
-            headers: {
-                Accept: 'application/json',
-                Authorization: `Bearer ${token}`,
-                ...(request.body === undefined ? {} : { 'Content-Type': 'application/json' }),
-                ...request.headers,
-            },
-            redirect: 'manual',
-        };
-        if (request.body !== undefined)
-            init.body = request.body;
-        if (signal !== undefined)
-            init.signal = signal;
-        try {
-            const response = await this.#transport.fetch(url.href, init);
-            if (response.url && new globalThis.URL(response.url).href !== url.href) {
-                await response.body?.cancel().catch(() => undefined);
-                throw new TargetProtocolError('Capsule response changed target route');
-            }
-            return response;
-        }
-        catch (error) {
-            if (error instanceof TargetAdapterError)
-                throw error;
-            throwIfAborted(signal);
-            throw new TargetTransportError('Capsule transport failed');
-        }
-    }
     #readJson(response) {
         return readBoundedResponseJson(response, MAX_RESPONSE_BYTES, (kind) => new TargetProtocolError(kind === 'size'
             ? 'Capsule response exceeds the size limit'

package/lib/target/discovery-validation.cjs

@@ -81,29 +81,22 @@ function parseCredentialInstall(value) {
     if (value === undefined || value === null)
         return null;
     const extension = closedRecord(value, 'extensions.credential_install', [
-        'kind', 'grant', 'install', 'upload_url_origin', 'sealed_envelope_algorithms', 'bounds',
+        'kind',
+        'install',
+        'max_body_bytes',
     ]);
     exact(extension.kind, 'openengine.capsule-credential-install/v1', 'extensions.credential_install.kind');
-    const grant = closedRecord(extension.grant, 'extensions.credential_install.grant', ['route_template', 'method']);
-    const install = closedRecord(extension.install, 'extensions.credential_install.install', ['route_template', 'method']);
-    exact(grant.method, 'POST', 'extensions.credential_install.grant.method');
-    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
-    exact(extension.upload_url_origin, 'same_origin', 'extensions.credential_install.upload_url_origin');
-    exactStringSet(extension.sealed_envelope_algorithms, 'extensions.credential_install.sealed_envelope_algorithms', ['RSA-OAEP-3072-SHA256']);
-    const bounds = closedRecord(extension.bounds, 'extensions.credential_install.bounds', [
-        'max_envelope_bytes', 'max_body_bytes', 'grant_ttl_seconds', 'max_clock_skew_seconds',
+    const install = closedRecord(extension.install, 'extensions.credential_install.install', [
+        'route_template',
+        'method',
     ]);
+    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
     return Object.freeze({
         kind: 'openengine.capsule-credential-install/v1',
-        grant: Object.freeze({ routeTemplate: (0, route_template_js_1.routeTemplate)(grant.route_template, 'extensions.credential_install.grant.route_template', ['capsule_id']), method: 'POST' }),
-        install: Object.freeze({ routeTemplate: (0, route_template_js_1.routeTemplate)(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']), method: 'PUT' }),
-        uploadUrlOrigin: 'same_origin',
-        sealedEnvelopeAlgorithms: Object.freeze(['RSA-OAEP-3072-SHA256']),
-        bounds: Object.freeze({
-            maxEnvelopeBytes: integer(bounds.max_envelope_bytes, 'extensions.credential_install.bounds.max_envelope_bytes', 1, 1_048_576),
-            maxBodyBytes: integer(bounds.max_body_bytes, 'extensions.credential_install.bounds.max_body_bytes', 1, 1_048_576),
-            grantTtlSeconds: integer(bounds.grant_ttl_seconds, 'extensions.credential_install.bounds.grant_ttl_seconds', 1, 3_600),
-            maxClockSkewSeconds: integer(bounds.max_clock_skew_seconds, 'extensions.credential_install.bounds.max_clock_skew_seconds', 0, 300),
+        install: Object.freeze({
+            routeTemplate: (0, route_template_js_1.routeTemplate)(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']),
+            method: 'PUT',
         }),
+        maxBodyBytes: integer(extension.max_body_bytes, 'extensions.credential_install.max_body_bytes', 1, 4 * 1024 * 1024),
     });
 }

package/lib/target/discovery-validation.d.cts

@@ -1,22 +1,11 @@
 import { type RouteTemplate } from './route-template.js';
 export interface CredentialInstallDescriptor {
     readonly kind: 'openengine.capsule-credential-install/v1';
-    readonly grant: {
-        readonly routeTemplate: RouteTemplate;
-        readonly method: 'POST';
-    };
     readonly install: {
         readonly routeTemplate: RouteTemplate;
         readonly method: 'PUT';
     };
-    readonly uploadUrlOrigin: 'same_origin';
-    readonly sealedEnvelopeAlgorithms: readonly ['RSA-OAEP-3072-SHA256'];
-    readonly bounds: {
-        readonly maxEnvelopeBytes: number;
-        readonly maxBodyBytes: number;
-        readonly grantTtlSeconds: number;
-        readonly maxClockSkewSeconds: number;
-    };
+    readonly maxBodyBytes: number;
 }
 export declare function record(value: unknown, field: string): Record<string, unknown>;
 export declare function closedRecord(value: unknown, field: string, fields: readonly string[]): Record<string, unknown>;

package/lib/target/discovery-validation.d.mts

@@ -1,22 +1,11 @@
 import { type RouteTemplate } from './route-template.js';
 export interface CredentialInstallDescriptor {
     readonly kind: 'openengine.capsule-credential-install/v1';
-    readonly grant: {
-        readonly routeTemplate: RouteTemplate;
-        readonly method: 'POST';
-    };
     readonly install: {
         readonly routeTemplate: RouteTemplate;
         readonly method: 'PUT';
     };
-    readonly uploadUrlOrigin: 'same_origin';
-    readonly sealedEnvelopeAlgorithms: readonly ['RSA-OAEP-3072-SHA256'];
-    readonly bounds: {
-        readonly maxEnvelopeBytes: number;
-        readonly maxBodyBytes: number;
-        readonly grantTtlSeconds: number;
-        readonly maxClockSkewSeconds: number;
-    };
+    readonly maxBodyBytes: number;
 }
 export declare function record(value: unknown, field: string): Record<string, unknown>;
 export declare function closedRecord(value: unknown, field: string, fields: readonly string[]): Record<string, unknown>;

package/lib/target/discovery-validation.d.ts

@@ -1,22 +1,11 @@
 import { type RouteTemplate } from './route-template.js';
 export interface CredentialInstallDescriptor {
     readonly kind: 'openengine.capsule-credential-install/v1';
-    readonly grant: {
-        readonly routeTemplate: RouteTemplate;
-        readonly method: 'POST';
-    };
     readonly install: {
         readonly routeTemplate: RouteTemplate;
         readonly method: 'PUT';
     };
-    readonly uploadUrlOrigin: 'same_origin';
-    readonly sealedEnvelopeAlgorithms: readonly ['RSA-OAEP-3072-SHA256'];
-    readonly bounds: {
-        readonly maxEnvelopeBytes: number;
-        readonly maxBodyBytes: number;
-        readonly grantTtlSeconds: number;
-        readonly maxClockSkewSeconds: number;
-    };
+    readonly maxBodyBytes: number;
 }
 export declare function record(value: unknown, field: string): Record<string, unknown>;
 export declare function closedRecord(value: unknown, field: string, fields: readonly string[]): Record<string, unknown>;

package/lib/target/discovery-validation.js

@@ -81,29 +81,22 @@ function parseCredentialInstall(value) {
     if (value === undefined || value === null)
         return null;
     const extension = closedRecord(value, 'extensions.credential_install', [
-        'kind', 'grant', 'install', 'upload_url_origin', 'sealed_envelope_algorithms', 'bounds',
+        'kind',
+        'install',
+        'max_body_bytes',
     ]);
     exact(extension.kind, 'openengine.capsule-credential-install/v1', 'extensions.credential_install.kind');
-    const grant = closedRecord(extension.grant, 'extensions.credential_install.grant', ['route_template', 'method']);
-    const install = closedRecord(extension.install, 'extensions.credential_install.install', ['route_template', 'method']);
-    exact(grant.method, 'POST', 'extensions.credential_install.grant.method');
-    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
-    exact(extension.upload_url_origin, 'same_origin', 'extensions.credential_install.upload_url_origin');
-    exactStringSet(extension.sealed_envelope_algorithms, 'extensions.credential_install.sealed_envelope_algorithms', ['RSA-OAEP-3072-SHA256']);
-    const bounds = closedRecord(extension.bounds, 'extensions.credential_install.bounds', [
-        'max_envelope_bytes', 'max_body_bytes', 'grant_ttl_seconds', 'max_clock_skew_seconds',
+    const install = closedRecord(extension.install, 'extensions.credential_install.install', [
+        'route_template',
+        'method',
     ]);
+    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
     return Object.freeze({
         kind: 'openengine.capsule-credential-install/v1',
-        grant: Object.freeze({ routeTemplate: (0, route_template_js_1.routeTemplate)(grant.route_template, 'extensions.credential_install.grant.route_template', ['capsule_id']), method: 'POST' }),
-        install: Object.freeze({ routeTemplate: (0, route_template_js_1.routeTemplate)(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']), method: 'PUT' }),
-        uploadUrlOrigin: 'same_origin',
-        sealedEnvelopeAlgorithms: Object.freeze(['RSA-OAEP-3072-SHA256']),
-        bounds: Object.freeze({
-            maxEnvelopeBytes: integer(bounds.max_envelope_bytes, 'extensions.credential_install.bounds.max_envelope_bytes', 1, 1_048_576),
-            maxBodyBytes: integer(bounds.max_body_bytes, 'extensions.credential_install.bounds.max_body_bytes', 1, 1_048_576),
-            grantTtlSeconds: integer(bounds.grant_ttl_seconds, 'extensions.credential_install.bounds.grant_ttl_seconds', 1, 3_600),
-            maxClockSkewSeconds: integer(bounds.max_clock_skew_seconds, 'extensions.credential_install.bounds.max_clock_skew_seconds', 0, 300),
+        install: Object.freeze({
+            routeTemplate: (0, route_template_js_1.routeTemplate)(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']),
+            method: 'PUT',
         }),
+        maxBodyBytes: integer(extension.max_body_bytes, 'extensions.credential_install.max_body_bytes', 1, 4 * 1024 * 1024),
     });
 }

package/lib/target/discovery-validation.mjs

@@ -71,29 +71,22 @@ export function parseCredentialInstall(value) {
     if (value === undefined || value === null)
         return null;
     const extension = closedRecord(value, 'extensions.credential_install', [
-        'kind', 'grant', 'install', 'upload_url_origin', 'sealed_envelope_algorithms', 'bounds',
+        'kind',
+        'install',
+        'max_body_bytes',
     ]);
     exact(extension.kind, 'openengine.capsule-credential-install/v1', 'extensions.credential_install.kind');
-    const grant = closedRecord(extension.grant, 'extensions.credential_install.grant', ['route_template', 'method']);
-    const install = closedRecord(extension.install, 'extensions.credential_install.install', ['route_template', 'method']);
-    exact(grant.method, 'POST', 'extensions.credential_install.grant.method');
-    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
-    exact(extension.upload_url_origin, 'same_origin', 'extensions.credential_install.upload_url_origin');
-    exactStringSet(extension.sealed_envelope_algorithms, 'extensions.credential_install.sealed_envelope_algorithms', ['RSA-OAEP-3072-SHA256']);
-    const bounds = closedRecord(extension.bounds, 'extensions.credential_install.bounds', [
-        'max_envelope_bytes', 'max_body_bytes', 'grant_ttl_seconds', 'max_clock_skew_seconds',
+    const install = closedRecord(extension.install, 'extensions.credential_install.install', [
+        'route_template',
+        'method',
     ]);
+    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
     return Object.freeze({
         kind: 'openengine.capsule-credential-install/v1',
-        grant: Object.freeze({ routeTemplate: routeTemplate(grant.route_template, 'extensions.credential_install.grant.route_template', ['capsule_id']), method: 'POST' }),
-        install: Object.freeze({ routeTemplate: routeTemplate(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']), method: 'PUT' }),
-        uploadUrlOrigin: 'same_origin',
-        sealedEnvelopeAlgorithms: Object.freeze(['RSA-OAEP-3072-SHA256']),
-        bounds: Object.freeze({
-            maxEnvelopeBytes: integer(bounds.max_envelope_bytes, 'extensions.credential_install.bounds.max_envelope_bytes', 1, 1_048_576),
-            maxBodyBytes: integer(bounds.max_body_bytes, 'extensions.credential_install.bounds.max_body_bytes', 1, 1_048_576),
-            grantTtlSeconds: integer(bounds.grant_ttl_seconds, 'extensions.credential_install.bounds.grant_ttl_seconds', 1, 3_600),
-            maxClockSkewSeconds: integer(bounds.max_clock_skew_seconds, 'extensions.credential_install.bounds.max_clock_skew_seconds', 0, 300),
+        install: Object.freeze({
+            routeTemplate: routeTemplate(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']),
+            method: 'PUT',
         }),
+        maxBodyBytes: integer(extension.max_body_bytes, 'extensions.credential_install.max_body_bytes', 1, 4 * 1024 * 1024),
     });
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.33.0",
+  "version": "6.34.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@the-open-engine/zeroshot",
-      "version": "6.33.0",
+      "version": "6.34.0",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.33.0",
+  "version": "6.34.0",
   "description": "Independent executor–verifier orchestration for software changes.",
   "main": "src/orchestrator.js",
   "bin": {
@@ -44,6 +44,7 @@
     "typecheck:agent-cli-provider": "tsc --project tsconfig.agent-cli-provider.json",
     "typecheck:hosted-target": "tsc --project tsconfig.hosted-target.json",
     "typecheck:hosted-session": "tsc --project tsconfig.hosted-session.json",
+    "test:hosted": "npm run build:cluster && node --test tests/private-hosted-cli/*.test.js && npm run test:hosted-target",
     "test:hosted-target": "npm run build:cluster && npm run build:target && node --test tests/hosted-target/*.test.ts",
     "test:target": "npm run build:agent-cli-provider && npm run build:target && node --test tests/target/*.test.ts",
     "typecheck:target": "tsc --project tsconfig.target.json",

package/src/agent/agent-config.js

@@ -21,12 +21,10 @@ const DEFAULT_MAX_ITERATIONS = 100;
 // Use positive number for timeout in milliseconds
 const DEFAULT_TIMEOUT = 0;
 
-// Stale detection - ENABLED by default using multi-indicator analysis (safe from false positives)
-// Multi-indicator approach checks: process state, CPU usage, context switches, network I/O
-// Only flags as stuck when ALL indicators show inactivity (score >= 3.5)
-// Single-indicator detection (just output freshness) was too risky - this is safe.
+// Output-silence detection is opt-in because healthy provider operations may be quiet for
+// longer than the stale threshold. Explicit task timeouts remain independently supported.
 const DEFAULT_STALE_DURATION_MS = 30 * 60 * 1000; // 30 minutes before triggering analysis
-const DEFAULT_LIVENESS_CHECK_ENABLED = true; // Safe with multi-indicator detection
+const DEFAULT_LIVENESS_CHECK_ENABLED = false;
 
 function applyOutputDefaults(config) {
   // CRITICAL: Enforce JSON schema output by default to prevent parse failures and crashes

package/src/agent-cli-provider/adapters/codex.ts

@@ -115,7 +115,9 @@ function addAutoApproveArgs(args: string[], options: BuildProviderCommandOptions
   const features = optionFeatures(options);
   if (options.autoApprove && features.supportsAutoApprove) {
     const sandboxMode =
-      options.executionContext === 'docker' ? 'danger-full-access' : 'workspace-write';
+      options.executionContext === 'docker' || options.executionContext === 'benchmark'
+        ? 'danger-full-access'
+        : 'workspace-write';
     args.push('--sandbox', sandboxMode, '--config', 'approval_policy="never"');
   }
 }

package/src/hosted-target/adapter-request.ts

@@ -1,12 +1,50 @@
 import type { RouteTemplate, TargetDiscoveryDescriptor } from '../target/discovery.js';
-import { TargetProtocolError } from './errors.js';
+import {
+  TargetAdapterError,
+  TargetAuthError,
+  TargetProtocolError,
+  TargetTransportError,
+} from './errors.js';
 import type { TargetOperation } from './retry-executor.js';
+import type { HttpTransport, TargetAccessTokenProvider } from './types.js';
+
+const DEFAULT_TRANSPORT: HttpTransport = {
+  fetch(url, init) {
+    return globalThis.fetch(url, init);
+  },
+};
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted)
+    throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
+}
+
+async function resolveAccessToken(
+  tokenProvider: TargetAccessTokenProvider,
+  accessToken: string | undefined,
+  signal: AbortSignal | undefined
+): Promise<string> {
+  if (accessToken !== undefined) return accessToken;
+  try {
+    return await tokenProvider.getAccessToken(signal);
+  } catch {
+    throw new TargetAuthError('Target access authorization failed');
+  }
+}
 
 export type AdapterRequest = {
   readonly body?: string;
   readonly headers?: Readonly<Record<string, string>>;
 };
 
+export type AdapterRequester = (input: {
+  readonly method: string;
+  readonly path: string;
+  readonly signal: AbortSignal | undefined;
+  readonly request: AdapterRequest;
+  readonly accessToken: string | undefined;
+}) => Promise<Response>;
+
 export type ExecuteArguments<T> = [
   operation: TargetOperation,
   method: string,
@@ -31,3 +69,39 @@ export function requestUrl(path: string, descriptor: TargetDiscoveryDescriptor):
   }
   return url;
 }
+
+export function createAdapterRequester(
+  descriptor: TargetDiscoveryDescriptor,
+  tokenProvider: TargetAccessTokenProvider,
+  transport: HttpTransport = DEFAULT_TRANSPORT
+): AdapterRequester {
+  return async ({ method, path, signal, request, accessToken }) => {
+    throwIfAborted(signal);
+    const url = requestUrl(path, descriptor);
+    const token = await resolveAccessToken(tokenProvider, accessToken, signal);
+    const init: RequestInit & { redirect: 'manual' } = {
+      method,
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${token}`,
+        ...(request.body === undefined ? {} : { 'Content-Type': 'application/json' }),
+        ...request.headers,
+      },
+      redirect: 'manual',
+    };
+    if (request.body !== undefined) init.body = request.body;
+    if (signal !== undefined) init.signal = signal;
+    try {
+      const response = await transport.fetch(url.href, init);
+      if (response.url && new globalThis.URL(response.url).href !== url.href) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new TargetProtocolError('Capsule response changed target route');
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof TargetAdapterError) throw error;
+      throwIfAborted(signal);
+      throw new TargetTransportError('Capsule transport failed');
+    }
+  };
+}

package/src/hosted-target/adapter-types.ts

@@ -26,6 +26,12 @@ export interface TargetAdapter {
   terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
   limits(signal?: AbortSignal): Promise<CapsuleLimits>;
   access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+  installRuntime(
+    capsuleId: string,
+    runtime: unknown,
+    accessToken: string,
+    signal?: AbortSignal
+  ): Promise<void>;
   readonly credentialInstall: CredentialInstallCapability;
 }
 

package/src/hosted-target/response-status.ts

@@ -0,0 +1,21 @@
+import { throwCapsuleServerError } from './capsule-error-response.js';
+import { TargetProtocolError } from './errors.js';
+import type { Clock } from './types.js';
+
+export async function assertCapsuleResponseStatus(
+  response: Response,
+  expectedStatus: number,
+  readJson: (response: Response) => Promise<unknown>,
+  clock: Clock
+): Promise<void> {
+  if (response.status >= 300 && response.status < 400) {
+    await response.body?.cancel().catch(() => undefined);
+    throw new TargetProtocolError('Capsule redirects are forbidden');
+  }
+  if (response.status === expectedStatus) return;
+  if (response.status >= 200 && response.status < 300) {
+    await response.body?.cancel().catch(() => undefined);
+    throw new TargetProtocolError('Target returned an unexpected success status');
+  }
+  await throwCapsuleServerError(response, readJson, clock);
+}

package/src/hosted-target/retry-executor.ts

@@ -2,7 +2,14 @@ import { MAX_RETRY_ELAPSED_MS } from './bounds.js';
 import { TargetAdapterError } from './errors.js';
 import type { Clock, RetryPolicy } from './types.js';
 
-export type TargetOperation = 'allocate' | 'list' | 'inspect' | 'terminate' | 'limits' | 'access';
+export type TargetOperation =
+  | 'allocate'
+  | 'list'
+  | 'inspect'
+  | 'terminate'
+  | 'limits'
+  | 'access'
+  | 'installRuntime';
 
 function throwIfAborted(signal?: AbortSignal): void {
   if (signal?.aborted) {