@the-open-engine/zeroshot 6.30.1 → 6.31.0

package/src/agent-cli-provider/omp/sdk-sidecar-context.ts

@@ -0,0 +1,199 @@
+import { promises as fs } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import type { OmpSdkSidecarRequest } from './sdk-protocol';
+import { openOmpAuthStorage } from './auth-policy';
+import {
+  PRIVATE_BASE_ENV_KEYS,
+  SidecarFailure,
+  isRecord,
+  isUnknownArray,
+  type CredentialChannel,
+  type OmpAuthStorage,
+  type OmpModel,
+  type OmpModelRegistry,
+  type OmpSdkBindings,
+  type PrivateState,
+} from './sdk-sidecar-types';
+
+export async function privateState(): Promise<PrivateState> {
+  const root = await fs.mkdtemp(join(tmpdir(), 'zeroshot-omp-sdk-'));
+  try {
+    await fs.chmod(root, 0o700);
+    const directories = [
+      'home',
+      'xdg-config',
+      'xdg-cache',
+      'xdg-data',
+      'xdg-state',
+      'agent',
+      'discovery-cwd',
+    ];
+    await Promise.all(directories.map((name) => fs.mkdir(join(root, name), { mode: 0o700 })));
+    return {
+      root,
+      agentDirectory: join(root, 'agent'),
+      authDatabasePath: join(root, 'agent', 'auth.db'),
+      brokerCachePath: join(root, 'agent', 'broker-snapshot.json'),
+      discoveryCwd: join(root, 'discovery-cwd'),
+      modelsPath: join(root, 'agent', 'models.yml'),
+    };
+  } catch {
+    await fs.rm(root, { force: true, maxRetries: 3, recursive: true });
+    throw new SidecarFailure('cleanup-error', 'cleanup', false);
+  }
+}
+export function isolateEnvironment(
+  state: PrivateState,
+  auth: OmpSdkSidecarRequest['auth']
+): Map<string, string | undefined> {
+  const original = new Map<string, string | undefined>();
+  const privateNames = new Set<string>(PRIVATE_BASE_ENV_KEYS);
+  for (const name of Object.keys(process.env)) {
+    if (name.startsWith('PI_') || name.startsWith('OMP_')) privateNames.add(name);
+  }
+  if (auth.mode === 'environment') {
+    Object.values(auth.credentials).forEach(({ env }) => privateNames.add(env));
+  }
+  for (const name of privateNames) {
+    original.set(name, process.env[name]);
+    delete process.env[name];
+  }
+  process.env.HOME = join(state.root, 'home');
+  process.env.XDG_CONFIG_HOME = join(state.root, 'xdg-config');
+  process.env.XDG_CACHE_HOME = join(state.root, 'xdg-cache');
+  process.env.XDG_DATA_HOME = join(state.root, 'xdg-data');
+  process.env.XDG_STATE_HOME = join(state.root, 'xdg-state');
+  process.env.PI_CODING_AGENT_DIR = state.agentDirectory;
+  return original;
+}
+export function restoreEnvironment(original: ReadonlyMap<string, string | undefined>): void {
+  for (const name of Object.keys(process.env)) {
+    if (name.startsWith('PI_') || name.startsWith('OMP_')) delete process.env[name];
+  }
+  original.forEach((value, key) => {
+    if (!PRIVATE_BASE_ENV_KEYS.some((name) => name === key)) {
+      delete process.env[key];
+    } else if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  });
+}
+export async function authStorage(
+  sdk: OmpSdkBindings,
+  request: OmpSdkSidecarRequest,
+  state: PrivateState,
+  provider: string,
+  credentials: CredentialChannel
+): Promise<OmpAuthStorage> {
+  const environmentSecret =
+    request.auth.mode === 'environment'
+      ? credentials.values[request.auth.credentials[provider]?.env ?? '']
+      : undefined;
+  if (request.auth.mode === 'environment' && !environmentSecret) {
+    throw new SidecarFailure('provider-auth', 'auth', false);
+  }
+  const brokerCredentials =
+    request.auth.mode === 'broker'
+      ? {
+          url: credentials.values.OMP_AUTH_BROKER_URL,
+          token: credentials.values.OMP_AUTH_BROKER_TOKEN,
+        }
+      : undefined;
+  if (request.auth.mode === 'broker' && (!brokerCredentials?.url || !brokerCredentials.token)) {
+    throw new SidecarFailure('provider-auth', 'auth', false);
+  }
+  const storage = await openOmpAuthStorage({
+    mode: request.auth.mode,
+    privateAgentDirectory: state.agentDirectory,
+    privateDatabasePath: state.authDatabasePath,
+    brokerCachePath: state.brokerCachePath,
+    sourceLabel: 'zeroshot omp sdk broker',
+    createDatabase: (databasePath) => sdk.AuthStorage.create(databasePath),
+    discoverBroker: (agentDirectory, options) =>
+      sdk.discoverBrokerAuthStorage(agentDirectory, options),
+    ...(request.auth.mode === 'omp-home' ? { sourceDirectory: request.auth.path } : {}),
+    ...(brokerCredentials === undefined ? {} : { brokerCredentials }),
+  });
+  if (typeof environmentSecret === 'string') {
+    storage.setRuntimeApiKey(provider, environmentSecret);
+  }
+  return storage;
+}
+export function exactModel(
+  sdk: OmpSdkBindings,
+  registry: OmpModelRegistry,
+  storage: OmpAuthStorage,
+  request: OmpSdkSidecarRequest
+): Readonly<OmpModel> {
+  const parsed = sdk.parseModelString(request.modelSelector);
+  const model = parsed === undefined ? undefined : registry.find(parsed.provider, parsed.id);
+  if (
+    parsed === undefined ||
+    `${parsed.provider}/${parsed.id}` !== request.modelSelector ||
+    model?.provider !== parsed.provider ||
+    model.id !== parsed.id
+  ) {
+    throw new SidecarFailure('model-resolution', 'model', false);
+  }
+  const available = registry
+    .getAvailable()
+    .find((candidate) => candidate.provider === parsed.provider && candidate.id === parsed.id);
+  if (
+    available === undefined ||
+    (request.auth.mode === 'none') === storage.hasAuth(parsed.provider)
+  ) {
+    throw new SidecarFailure('provider-auth', 'auth', false);
+  }
+  const providerConfig = request.modelsConfig.providers[parsed.provider];
+  const models = isUnknownArray(providerConfig?.models) ? providerConfig.models : [];
+  const declaredModel = models.find(
+    (candidate) => isRecord(candidate) && candidate.id === parsed.id
+  );
+  const declaredBaseUrl =
+    isRecord(declaredModel) && typeof declaredModel.baseUrl === 'string'
+      ? declaredModel.baseUrl
+      : typeof providerConfig?.baseUrl === 'string'
+        ? providerConfig.baseUrl
+        : undefined;
+  const declaredApi =
+    isRecord(declaredModel) && typeof declaredModel.api === 'string'
+      ? declaredModel.api
+      : typeof providerConfig?.api === 'string'
+        ? providerConfig.api
+        : undefined;
+  const routeExposed = model.api !== undefined || model.baseUrl !== undefined;
+  const availableRouteExposed = available.api !== undefined || available.baseUrl !== undefined;
+  if (
+    routeExposed !== availableRouteExposed ||
+    (routeExposed && (model.api === undefined || model.baseUrl === undefined)) ||
+    (availableRouteExposed && (available.api === undefined || available.baseUrl === undefined)) ||
+    (routeExposed && declaredBaseUrl !== undefined && model.baseUrl !== declaredBaseUrl) ||
+    (routeExposed && declaredApi !== undefined && model.api !== declaredApi) ||
+    model.api !== available.api ||
+    model.baseUrl !== available.baseUrl
+  ) {
+    throw new SidecarFailure('model-resolution', 'model', false);
+  }
+  return Object.freeze({
+    provider: model.provider,
+    id: model.id,
+    ...(model.api === undefined ? {} : { api: model.api }),
+    ...(model.baseUrl === undefined ? {} : { baseUrl: model.baseUrl }),
+  });
+}
+export function privateModelsConfig(request: OmpSdkSidecarRequest): {
+  readonly providers: Readonly<Record<string, Record<string, unknown>>>;
+} {
+  const providers: Record<string, Record<string, unknown>> = {};
+  for (const [provider, config] of Object.entries(request.modelsConfig.providers)) {
+    const copy: unknown = JSON.parse(JSON.stringify(config));
+    if (!isRecord(copy)) throw new SidecarFailure('invalid-request', 'request', false);
+    delete copy.apiKey;
+    providers[provider] = copy;
+  }
+  return { providers };
+}

package/src/agent-cli-provider/omp/sdk-sidecar-credentials.ts

@@ -0,0 +1,100 @@
+import { closeSync, readSync } from 'node:fs';
+import { TextDecoder } from 'node:util';
+
+import { OMP_SDK_MAX_CREDENTIAL_BYTES, type OmpSdkSidecarRequest } from './sdk-protocol';
+import {
+  CREDENTIAL_NAME,
+  MAX_CREDENTIAL_COUNT,
+  MAX_CREDENTIAL_NAME_BYTES,
+  MAX_CREDENTIAL_VALUE_BYTES,
+  SidecarFailure,
+  isRecord,
+  type CredentialChannel,
+} from './sdk-sidecar-types';
+
+function closeCredentialChannel(fd: number): void {
+  try {
+    closeSync(fd);
+  } catch {
+    throw new SidecarFailure('invalid-request', 'request', false);
+  }
+}
+export function readCredentialChannel(fd: number): CredentialChannel {
+  if (!Number.isInteger(fd) || fd < 3) {
+    throw new SidecarFailure('invalid-request', 'request', false);
+  }
+  const buffer = Buffer.allocUnsafe(OMP_SDK_MAX_CREDENTIAL_BYTES + 1);
+  let offset = 0;
+  try {
+    while (offset <= OMP_SDK_MAX_CREDENTIAL_BYTES) {
+      const count = readSync(fd, buffer, offset, buffer.byteLength - offset, null);
+      if (count === 0) break;
+      offset += count;
+    }
+  } catch {
+    throw new SidecarFailure('invalid-request', 'request', false);
+  } finally {
+    closeCredentialChannel(fd);
+  }
+  if (offset === 0 || offset > OMP_SDK_MAX_CREDENTIAL_BYTES) {
+    throw new SidecarFailure('invalid-request', 'request', false);
+  }
+  let parsed: unknown;
+  try {
+    const text = new TextDecoder('utf-8', { fatal: true }).decode(buffer.subarray(0, offset));
+    parsed = JSON.parse(text);
+  } catch {
+    throw new SidecarFailure('invalid-request', 'request', false);
+  }
+  if (
+    !isRecord(parsed) ||
+    Object.keys(parsed).length !== 2 ||
+    parsed.protocolVersion !== 1 ||
+    !isRecord(parsed.values)
+  ) {
+    throw new SidecarFailure('invalid-request', 'request', false);
+  }
+  const entries = Object.entries(parsed.values);
+  if (entries.length > MAX_CREDENTIAL_COUNT) {
+    throw new SidecarFailure('invalid-request', 'request', false);
+  }
+  const values: Record<string, string> = {};
+  for (const [name, value] of entries) {
+    if (
+      !CREDENTIAL_NAME.test(name) ||
+      Buffer.byteLength(name) > MAX_CREDENTIAL_NAME_BYTES ||
+      typeof value !== 'string' ||
+      value.length === 0 ||
+      Buffer.byteLength(value) > MAX_CREDENTIAL_VALUE_BYTES
+    ) {
+      throw new SidecarFailure('invalid-request', 'request', false);
+    }
+    values[name] = value;
+  }
+  return { values: Object.freeze(values) };
+}
+export function credentialsForRequest(
+  request: OmpSdkSidecarRequest,
+  channel: CredentialChannel
+): CredentialChannel {
+  const provider = request.modelSelector.slice(0, request.modelSelector.indexOf('/'));
+  let expected: readonly string[];
+  if (request.auth.mode === 'environment') {
+    const reference = request.auth.credentials[provider];
+    if (reference === undefined) throw new SidecarFailure('provider-auth', 'auth', false);
+    expected = [reference.env];
+  } else if (request.auth.mode === 'broker') {
+    expected = ['OMP_AUTH_BROKER_TOKEN', 'OMP_AUTH_BROKER_URL'];
+  } else {
+    expected = [];
+  }
+  const actual = Object.keys(channel.values).sort((left, right) => left.localeCompare(right));
+  const sortedExpected = [...expected].sort((left, right) => left.localeCompare(right));
+  if (
+    actual.length !== sortedExpected.length ||
+    actual.some((name, index) => name !== sortedExpected[index])
+  ) {
+    throw new SidecarFailure('provider-auth', 'auth', false);
+  }
+  return channel;
+}

package/src/agent-cli-provider/omp/sdk-sidecar-execute.ts

@@ -0,0 +1,201 @@
+import { promises as fs } from 'node:fs';
+import { isDeepStrictEqual } from 'node:util';
+
+import {
+  OMP_SDK_BUN_VERSION,
+  OMP_SDK_MAX_FRAME_BYTES,
+  OMP_SDK_TEXT_OUTPUT_SCHEMA,
+  parseOmpSdkSidecarRequest,
+  type OmpSdkProtocolFrame,
+  type OmpSdkSidecarRequest,
+} from './sdk-protocol';
+import { compilePrivateOmpModelsYaml } from './sdk-settings';
+import { credentialsForRequest, readCredentialChannel } from './sdk-sidecar-credentials';
+import {
+  authStorage,
+  exactModel,
+  isolateEnvironment,
+  privateModelsConfig,
+  privateState,
+  restoreEnvironment,
+} from './sdk-sidecar-context';
+import { resultFrame, successfulValue } from './sdk-sidecar-output';
+import {
+  bunVersion,
+  createOmpSdkErrorFrame,
+  loadOmpSdk,
+  requireOmpModelRegistry,
+  runIdFrom,
+} from './sdk-sidecar-runtime';
+import {
+  ISOLATED_SETTINGS,
+  SidecarFailure,
+  type CredentialChannel,
+  type OmpAuthStorage,
+  type OmpSdkSidecarOptions,
+} from './sdk-sidecar-types';
+
+async function execute(
+  request: OmpSdkSidecarRequest,
+  credentials: CredentialChannel,
+  options: OmpSdkSidecarOptions
+): Promise<OmpSdkProtocolFrame> {
+  if ((options.runtimeVersion ?? bunVersion)() !== OMP_SDK_BUN_VERSION) {
+    throw new SidecarFailure('sdk-error', 'sdk', false);
+  }
+  const state = await privateState();
+  const originalCwd = process.cwd();
+  const original = isolateEnvironment(state, request.auth);
+  let storage: OmpAuthStorage | undefined;
+  let candidate: OmpSdkProtocolFrame | undefined;
+  let failure: unknown;
+  let changedCwd = false;
+  try {
+    process.chdir(state.discoveryCwd);
+    changedCwd = true;
+    await fs.writeFile(
+      state.modelsPath,
+      compilePrivateOmpModelsYaml(privateModelsConfig(request)),
+      {
+        encoding: 'utf8',
+        flag: 'wx',
+        mode: 0o600,
+      }
+    );
+    await fs.chmod(state.modelsPath, 0o600);
+    const sdk = await (options.loadOmpSdk ?? loadOmpSdk)();
+    const parsed = sdk.parseModelString(request.modelSelector);
+    if (parsed === undefined) throw new SidecarFailure('model-resolution', 'model', false);
+    storage = await authStorage(sdk, request, state, parsed.provider, credentials);
+    const registry = requireOmpModelRegistry(new sdk.ModelRegistry(storage, state.modelsPath));
+    if (registry.getError() !== undefined) {
+      throw new SidecarFailure('invalid-request', 'request', false);
+    }
+    const effectiveModel = exactModel(sdk, registry, storage, request);
+    const base = sdk.getBundledAgent('task');
+    if (base === undefined) throw new SidecarFailure('sdk-error', 'sdk', false);
+    const settings = sdk.Settings.isolated({
+      ...ISOLATED_SETTINGS,
+      enabledModels: [request.modelSelector],
+    });
+    const agent = {
+      ...base,
+      tools: [...request.tools],
+      spawns: [],
+      model: [request.modelSelector],
+      thinkingLevel: request.reasoningEffort,
+      autoloadSkills: [],
+      prewalk: false,
+    };
+    const schema =
+      request.outputMode === 'text' ? OMP_SDK_TEXT_OUTPUT_SCHEMA : request.outputSchema;
+    const result = await sdk.runSubprocess({
+      cwd: request.cwd,
+      agent,
+      task: request.prompt,
+      context: request.context,
+      description: 'Zeroshot strict SDK execution',
+      index: 0,
+      id: request.runId,
+      modelOverride: request.modelSelector,
+      thinkingLevel: request.reasoningEffort,
+      outputSchema: schema,
+      outputSchemaMode: 'strict',
+      outputSchemaSource: 'caller',
+      outputSchemaOverridesAgent: true,
+      settings,
+      authStorage: storage,
+      modelRegistry: registry,
+      restrictToolNames: true,
+      enableMCP: false,
+      enableIrc: false,
+      enableLsp: request.tools.includes('lsp'),
+      contextFiles: [],
+      skills: [],
+      promptTemplates: [],
+      workspaceTree: {
+        rootPath: request.cwd,
+        rendered: '',
+        truncated: false,
+        totalLines: 0,
+        agentsMdFiles: [],
+      },
+      rules: [],
+      preloadedExtensionPaths: [],
+      preloadedCustomToolPaths: [],
+      keepAlive: false,
+      signal: options.signal,
+    });
+    const rawValue = successfulValue(result, request, schema, options.signal);
+    if (
+      registry.getError() !== undefined ||
+      !isDeepStrictEqual(effectiveModel, exactModel(sdk, registry, storage, request))
+    ) {
+      throw new SidecarFailure('model-resolution', 'model', false);
+    }
+    candidate = resultFrame(request, result, rawValue);
+  } catch (error) {
+    failure = error;
+  } finally {
+    try {
+      storage?.close();
+    } catch {
+      failure = new SidecarFailure('cleanup-error', 'cleanup', false);
+    }
+    if (changedCwd) {
+      try {
+        process.chdir(originalCwd);
+      } catch {
+        failure = new SidecarFailure('cleanup-error', 'cleanup', false);
+      }
+    }
+    restoreEnvironment(original);
+    try {
+      await fs.rm(state.root, { force: true, maxRetries: 3, recursive: true });
+    } catch {
+      failure = new SidecarFailure('cleanup-error', 'cleanup', false);
+    }
+  }
+  if (options.signal?.aborted) {
+    throw new SidecarFailure('cancelled', 'cancelled', false);
+  }
+  if (failure !== undefined) throw failure;
+  if (candidate === undefined) throw new SidecarFailure('internal-error', 'internal', false);
+  return candidate;
+}
+
+export async function executeOmpSdkSidecar(
+  input: unknown,
+  options: OmpSdkSidecarOptions = {}
+): Promise<OmpSdkProtocolFrame> {
+  const runId = runIdFrom(input);
+  let channel: CredentialChannel;
+  try {
+    channel = readCredentialChannel(options.credentialChannelFd ?? 3);
+  } catch (error) {
+    return createOmpSdkErrorFrame(runId, error);
+  }
+  let request: OmpSdkSidecarRequest;
+  try {
+    request = parseOmpSdkSidecarRequest(input);
+  } catch {
+    return createOmpSdkErrorFrame(runId, new SidecarFailure('invalid-request', 'request', false));
+  }
+  try {
+    channel = credentialsForRequest(request, channel);
+  } catch (error) {
+    return createOmpSdkErrorFrame(runId, error);
+  }
+  try {
+    return await execute(request, channel, options);
+  } catch (error) {
+    return createOmpSdkErrorFrame(runId, error);
+  }
+}
+export function serializeOmpSdkFrame(frame: OmpSdkProtocolFrame): string {
+  const serialized = `${JSON.stringify(frame)}\n`;
+  if (Buffer.byteLength(serialized) <= OMP_SDK_MAX_FRAME_BYTES) return serialized;
+  return `${JSON.stringify(
+    createOmpSdkErrorFrame(frame.runId, new SidecarFailure('invalid-request', 'request', false))
+  )}\n`;
+}