@the-open-engine/zeroshot 6.33.0 → 6.34.0

package/src/hosted-target/runtime-install.ts

@@ -0,0 +1,83 @@
+import type { CredentialInstallDescriptor } from '../target/discovery.js';
+import { readBoundedResponseJson } from '../target/bounded-response.js';
+import { MAX_RESPONSE_BYTES } from './bounds.js';
+import { TargetProtocolError } from './errors.js';
+import { assertCapsuleResponseStatus } from './response-status.js';
+import { withTargetRetry } from './retry-executor.js';
+import type { Clock, RetryPolicy } from './types.js';
+
+type RuntimeInstallOptions = {
+  readonly capsuleId: string;
+  readonly runtime: unknown;
+  readonly accessToken: string;
+  readonly descriptor: CredentialInstallDescriptor;
+  readonly signal?: AbortSignal;
+  readonly clock: Clock;
+  readonly retryPolicy: RetryPolicy;
+  readonly request: (
+    method: string,
+    path: string,
+    signal: AbortSignal | undefined,
+    body: string,
+    accessToken: string
+  ) => Promise<Response>;
+};
+
+function validOpaque(value: string, field: string): void {
+  if (value.length === 0 || value.length > 1024) {
+    throw new TargetProtocolError(`${field} is invalid`);
+  }
+}
+
+function runtimeBody(runtime: unknown, maximum: number): string {
+  let body: string | undefined;
+  try {
+    body = JSON.stringify(runtime);
+  } catch {
+    throw new TargetProtocolError('Runtime bundle is not serializable');
+  }
+  if (body === undefined || Buffer.byteLength(body) > maximum) {
+    throw new TargetProtocolError('Runtime bundle exceeds the advertised size bound');
+  }
+  return body;
+}
+
+export async function installRuntime(options: RuntimeInstallOptions): Promise<void> {
+  validOpaque(options.capsuleId, 'capsule id');
+  validOpaque(options.accessToken, 'capsule access token');
+  let path: string;
+  try {
+    path = options.descriptor.install.routeTemplate.expand({
+      capsule_id: options.capsuleId,
+    });
+  } catch {
+    throw new TargetProtocolError('Runtime install route expansion is unsafe');
+  }
+  const body = runtimeBody(options.runtime, options.descriptor.maxBodyBytes);
+  await withTargetRetry(
+    'installRuntime',
+    async () => {
+      const response = await options.request(
+        options.descriptor.install.method,
+        path,
+        options.signal,
+        body,
+        options.accessToken
+      );
+      await assertCapsuleResponseStatus(
+        response,
+        204,
+        (errorResponse) =>
+          readBoundedResponseJson(
+            errorResponse,
+            MAX_RESPONSE_BYTES,
+            () => new TargetProtocolError('Capsule error response is malformed')
+          ),
+        options.clock
+      );
+      await response.body?.cancel().catch(() => undefined);
+    },
+    options.signal,
+    { clock: options.clock, policy: options.retryPolicy }
+  );
+}

package/src/hosted-target/zero-cloud-v1-adapter.ts

@@ -1,10 +1,5 @@
 import { IDEMPOTENCY_KEY_PATTERN, MAX_RESPONSE_BYTES } from './bounds.js';
-import {
-  TargetAdapterError,
-  TargetAuthError,
-  TargetProtocolError,
-  TargetTransportError,
-} from './errors.js';
+import { TargetProtocolError } from './errors.js';
 import { DefaultRetryPolicy } from './retry.js';
 import {
   assertCapsule,
@@ -20,34 +15,23 @@ import type {
   CapsuleLimits,
   CapsuleListPage,
   Clock,
-  HttpTransport,
   ListRequest,
   RetryPolicy,
-  TargetAccessTokenProvider,
 } from './types.js';
 import type { TargetDiscoveryDescriptor } from '../target/discovery.js';
 import { readBoundedResponseJson } from '../target/bounded-response.js';
-import { throwCapsuleServerError } from './capsule-error-response.js';
 import { validateAccessUrl } from './access-url.js';
 import { withTargetRetry } from './retry-executor.js';
+import { installRuntime as installOpaqueRuntime } from './runtime-install.js';
+import { assertCapsuleResponseStatus } from './response-status.js';
 import {
-  requestUrl,
-  type AdapterRequest,
+  createAdapterRequester,
+  type AdapterRequester,
   type ExecuteArguments,
 } from './adapter-request.js';
 
-const DEFAULT_TRANSPORT: HttpTransport = {
-  fetch(url, init) {
-    return globalThis.fetch(url, init);
-  },
-};
 const DEFAULT_CLOCK: Clock = { now: () => Date.now() };
 
-function throwIfAborted(signal?: AbortSignal): void {
-  if (signal?.aborted)
-    throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
-}
-
 function validOpaque(value: string, field: string): void {
   if (value.length === 0 || value.length > 1024)
     throw new TargetProtocolError(`${field} is invalid`);
@@ -57,12 +41,10 @@ function jsonRequest(body: unknown): string {
   return JSON.stringify(body);
 }
 
-
 export class ZeroCloudV1TargetAdapter implements TargetAdapter {
   readonly #descriptor: TargetDiscoveryDescriptor;
   readonly #organizationId: string;
-  readonly #tokenProvider: TargetAccessTokenProvider;
-  readonly #transport: HttpTransport;
+  readonly #request: AdapterRequester;
   readonly #clock: Clock;
   readonly #retryPolicy: RetryPolicy;
 
@@ -70,8 +52,11 @@ export class ZeroCloudV1TargetAdapter implements TargetAdapter {
     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();
   }
@@ -199,21 +184,42 @@ export class ZeroCloudV1TargetAdapter implements TargetAdapter {
     return result;
   }
 
+  async installRuntime(
+    capsuleId: string,
+    runtime: unknown,
+    accessToken: string,
+    signal?: AbortSignal
+  ): Promise<void> {
+    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<T>(...args: ExecuteArguments<T>): Promise<T> {
     return Promise.resolve().then(() => this.#executeExpanded(args));
   }
 
   #executeExpanded<T>(args: ExecuteArguments<T>): Promise<T> {
-    const [
-      operation,
-      method,
-      template,
-      values,
-      expectedStatus,
-      validate,
-      signal,
-      request = {},
-    ] = args;
+    const [operation, method, template, values, expectedStatus, validate, signal, request = {}] =
+      args;
     let path: string;
     try {
       path = template.expand(values);
@@ -223,77 +229,36 @@ export class ZeroCloudV1TargetAdapter implements TargetAdapter {
     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 },
+      { clock: this.#clock, policy: this.#retryPolicy }
     );
   }
 
-  async #request(
-    method: string,
-    path: string,
-    signal: AbortSignal | undefined,
-    request: AdapterRequest,
-  ): Promise<Response> {
-    throwIfAborted(signal);
-    const url = requestUrl(path, this.#descriptor);
-    let token: string;
-    try {
-      token = await this.#tokenProvider.getAccessToken(signal);
-    } catch {
-      throw new TargetAuthError('Target access authorization failed');
-    }
-    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 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: Response): Promise<unknown> {
-    return readBoundedResponseJson(response, MAX_RESPONSE_BYTES, (kind) =>
-      new TargetProtocolError(
-        kind === 'size'
-          ? 'Capsule response exceeds the size limit'
-          : 'Capsule response is not valid UTF-8 JSON',
-      ),
+    return readBoundedResponseJson(
+      response,
+      MAX_RESPONSE_BYTES,
+      (kind) =>
+        new TargetProtocolError(
+          kind === 'size'
+            ? 'Capsule response exceeds the size limit'
+            : 'Capsule response is not valid UTF-8 JSON'
+        )
     );
   }
 }

package/src/target/discovery-validation.ts

@@ -3,16 +3,8 @@ import { routeTemplate, 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 function record(value: unknown, field: string): Record<string, unknown> {
@@ -116,29 +108,35 @@ export function sameOriginUrl(
 export function parseCredentialInstall(value: unknown): CredentialInstallDescriptor | null {
   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',
+  exact(
+    extension.kind,
+    'openengine.capsule-credential-install/v1',
+    'extensions.credential_install.kind'
+  );
+  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' as const,
-    grant: Object.freeze({ routeTemplate: routeTemplate(grant.route_template, 'extensions.credential_install.grant.route_template', ['capsule_id']), method: 'POST' as const }),
-    install: Object.freeze({ routeTemplate: routeTemplate(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']), method: 'PUT' as const }),
-    uploadUrlOrigin: 'same_origin' as const,
-    sealedEnvelopeAlgorithms: Object.freeze(['RSA-OAEP-3072-SHA256'] as const),
-    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' as const,
     }),
+    maxBodyBytes: integer(
+      extension.max_body_bytes,
+      'extensions.credential_install.max_body_bytes',
+      1,
+      4 * 1024 * 1024
+    ),
   });
 }

package/task-lib/runner.js

@@ -43,6 +43,8 @@ const {
   partitionPathFor,
   createOmpSessionPartitionDirectory,
 } = require('../src/omp-session-partition');
+const TASK_EXECUTION_CONTEXT_ENV = 'ZEROSHOT_TASK_EXECUTION_CONTEXT';
+const TASK_EXECUTION_CONTEXTS = new Set(['host', 'detached', 'docker', 'benchmark']);
 export {
   isOwnedProcessTreeRunning,
   isProcessRunning,
@@ -413,7 +415,7 @@ function buildProviderOptions(options, runtime, modelSelection) {
     outputFormat: runtime.outputFormat,
     jsonSchema: runtime.jsonSchema,
     cwd: runtime.cwd,
-    executionContext: 'detached',
+    executionContext: resolveTaskExecutionContext(),
     autoApprove: !structuredOutputRecovery,
     ...(modelSelection === undefined ? {} : { modelSpec: modelSelection.modelSpec }),
     ...(structuredOutputRecovery ? {} : mcpConfigOption(options)),
@@ -428,6 +430,17 @@ function buildProviderOptions(options, runtime, modelSelection) {
   };
 }
 
+export function resolveTaskExecutionContext(environment = process.env) {
+  const context = environment[TASK_EXECUTION_CONTEXT_ENV];
+  if (context === undefined) return 'detached';
+  if (!TASK_EXECUTION_CONTEXTS.has(context)) {
+    throw new Error(
+      `${TASK_EXECUTION_CONTEXT_ENV} must be one of: ${[...TASK_EXECUTION_CONTEXTS].join(', ')}.`
+    );
+  }
+  return context;
+}
+
 function claudeSettingsFileOption() {
   const settingsPath = process.env[CLAUDE_SETTINGS_ENV]?.trim();
   return settingsPath ? { claudeSettingsFile: settingsPath } : {};