ag-ai 0.1.0

package/runtime/executor/opencode.mjs

@@ -0,0 +1,430 @@
+import { readFile } from 'node:fs/promises';
+
+const DEFAULT_OPENCODE_URL = 'http://127.0.0.1:4096';
+const DEFAULT_OPENCODE_USERNAME = 'opencode';
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+const DEFAULT_REASONING_EFFORT = 'medium';
+const MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
+const MAX_ERROR_BYTES = 16 * 1024;
+const MAX_TEXT_BYTES = 2 * 1024 * 1024;
+
+/**
+ * @typedef {object} Executor
+ * @property {string} name Executor identifier.
+ * @property {(request: object, options?: { signal?: AbortSignal, directory?: string }) =>
+ *   Promise<{ output: object[], model: string, generatedAt: number, usage?: object }>} execute
+ *   Run one canonical generation request.
+ */
+
+class ExecutorError extends Error {
+  constructor(message, { status } = {}) {
+    super(message);
+    this.name = 'ExecutorError';
+    if (status !== undefined) this.status = status;
+  }
+}
+
+const asObject = (value) => (value && typeof value === 'object' ? value : null);
+
+const boundedString = (value, maximum, name) => {
+  if (typeof value !== 'string' || value.length === 0 || value.length > maximum) {
+    throw new ExecutorError(`${name} is invalid`);
+  }
+  return value;
+};
+
+const readResponseBytes = async (response, maximum) => {
+  const contentLength = Number(response.headers.get('content-length'));
+  if (Number.isFinite(contentLength) && contentLength > maximum) {
+    throw new ExecutorError('OpenCode response exceeds its size limit');
+  }
+  if (!response.body) return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (;;) {
+      // eslint-disable-next-line no-await-in-loop -- response bytes must be bounded sequentially.
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = Buffer.from(value);
+      total += chunk.length;
+      if (total > maximum) {
+        // eslint-disable-next-line no-await-in-loop -- cancelling the reader is part of the bounded read.
+        await reader.cancel();
+        throw new ExecutorError('OpenCode response exceeds its size limit');
+      }
+      chunks.push(chunk);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total);
+};
+
+const combineSignals = (signal, timeoutMs) => {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal === undefined ? timeout : AbortSignal.any([signal, timeout]);
+};
+
+const normalizeBaseUrl = (value) => {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ExecutorError('AG_AI_OPENCODE_URL must be an absolute URL');
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new ExecutorError('AG_AI_OPENCODE_URL must use http or https');
+  }
+  return url.toString().replace(/\/+$/, '');
+};
+
+const basicAuth = (username, password) =>
+  `Basic ${Buffer.from(`${username}:${password}`, 'utf8').toString('base64')}`;
+
+const dataUrl = (mimeType, data) => `data:${mimeType};base64,${data}`;
+
+const modelReference = (model, providerID) => {
+  if (model === undefined) return undefined;
+  if (typeof model !== 'string' || model.trim().length === 0) {
+    throw new ExecutorError('OpenCode model is invalid');
+  }
+  const normalized = model.trim();
+  if (normalized.includes('/')) {
+    const separator = normalized.indexOf('/');
+    const provider = normalized.slice(0, separator);
+    const modelID = normalized.slice(separator + 1);
+    if (provider.length === 0 || modelID.length === 0) {
+      throw new ExecutorError('OpenCode model must be "provider/model"');
+    }
+    return { providerID: provider, modelID };
+  }
+  if (providerID === undefined) {
+    throw new ExecutorError('OpenCode model must be "provider/model"');
+  }
+  return { providerID, modelID: normalized };
+};
+
+const partsFromInput = (request) => {
+  const parts = [];
+  if (typeof request.instructions === 'string' && request.instructions.length > 0) {
+    parts.push({ type: 'text', text: request.instructions });
+  }
+  const input = Array.isArray(request.input) ? request.input : [];
+  for (const message of input) {
+    const content = Array.isArray(message?.content) ? message.content : [];
+    for (const part of content) {
+      if (part?.type === 'text') {
+        parts.push({ type: 'text', text: boundedString(part.text, MAX_TEXT_BYTES, 'input text') });
+        continue;
+      }
+      if (
+        part?.type === 'image' ||
+        part?.type === 'audio' ||
+        part?.type === 'video' ||
+        part?.type === 'file'
+      ) {
+        const mimeType = boundedString(part.mimeType, 160, 'input mimeType');
+        const data = boundedString(part.data, MAX_RESPONSE_BYTES, 'input data');
+        parts.push({
+          type: 'file',
+          mime: mimeType,
+          ...(typeof part.name === 'string' && part.name.length > 0 ? { filename: part.name } : {}),
+          url: dataUrl(mimeType, data),
+        });
+        continue;
+      }
+      throw new ExecutorError('input content part type is unsupported');
+    }
+  }
+  if (parts.length === 0) throw new ExecutorError('OpenCode request has no input parts');
+  return parts;
+};
+
+const promptText = (request) => {
+  const text = [];
+  if (typeof request.instructions === 'string' && request.instructions.length > 0) {
+    text.push(request.instructions);
+  }
+  const input = Array.isArray(request.input) ? request.input : [];
+  for (const message of input) {
+    for (const part of Array.isArray(message?.content) ? message.content : []) {
+      if (part?.type === 'text' && typeof part.text === 'string') text.push(part.text);
+    }
+  }
+  return text.join('\n').trim();
+};
+
+const referenceImages = (request) => {
+  const images = [];
+  const input = Array.isArray(request.input) ? request.input : [];
+  for (const message of input) {
+    for (const part of Array.isArray(message?.content) ? message.content : []) {
+      if (part?.type === 'image') {
+        images.push({
+          mimeType: part.mimeType,
+          data: part.data,
+          ...(typeof part.name === 'string' ? { name: part.name } : {}),
+        });
+      }
+    }
+  }
+  return images;
+};
+
+const textFromParts = (parts) => {
+  if (!Array.isArray(parts)) throw new ExecutorError('OpenCode returned invalid message parts');
+  return parts
+    .filter((part) => asObject(part)?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('');
+};
+
+const usageFromTokens = (tokens) => {
+  const usage = asObject(tokens);
+  if (!usage) return undefined;
+  const inputTokens = usage.input;
+  const outputTokens = usage.output;
+  if (!Number.isInteger(inputTokens) || inputTokens < 0) return undefined;
+  if (!Number.isInteger(outputTokens) || outputTokens < 0) return undefined;
+  return { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
+};
+
+/**
+ * Create an executor backed by an OpenCode HTTP server. The server URL comes
+ * from `AG_AI_OPENCODE_URL`; the basic-auth password comes from
+ * `AG_AI_OPENCODE_PASSWORD_FILE` (username `opencode` unless
+ * `AG_AI_OPENCODE_USERNAME` is set). No SDK dependency is used.
+ *
+ * @param {{
+ *   baseUrl?: string,
+ *   username?: string,
+ *   password?: string,
+ *   passwordFile?: string,
+ *   fetch?: typeof globalThis.fetch,
+ *   imageAdapter?: import('../image/adapter.mjs').ImageAdapter,
+ *   providerID?: string,
+ *   timeoutMs?: number,
+ *   now?: () => number,
+ * }} options
+ * @returns {Promise<Executor & {
+ *   listModels: (options?: object) => Promise<object[]>,
+ *   health: () => Promise<{ healthy: boolean, version?: string }>,
+ * }>}
+ */
+const createOpenCodeExecutor = async ({
+  baseUrl = process.env.AG_AI_OPENCODE_URL ?? DEFAULT_OPENCODE_URL,
+  username = process.env.AG_AI_OPENCODE_USERNAME ?? DEFAULT_OPENCODE_USERNAME,
+  password,
+  passwordFile = process.env.AG_AI_OPENCODE_PASSWORD_FILE,
+  fetch: fetchImpl = globalThis.fetch,
+  imageAdapter,
+  providerID = process.env.AG_AI_OPENCODE_PROVIDER,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  now = () => Date.now(),
+} = {}) => {
+  if (typeof fetchImpl !== 'function') {
+    throw new ExecutorError('OpenCode fetch implementation is required');
+  }
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  let resolvedPassword = typeof password === 'string' && password.length > 0 ? password : undefined;
+  if (
+    resolvedPassword === undefined &&
+    typeof passwordFile === 'string' &&
+    passwordFile.length > 0
+  ) {
+    try {
+      const value = (await readFile(passwordFile, 'utf8')).trim();
+      if (value.length > 0) resolvedPassword = value;
+    } catch (error) {
+      if (error?.code !== 'ENOENT') {
+        throw new ExecutorError(
+          `OpenCode password file could not be read: ${error?.code ?? 'error'}`,
+        );
+      }
+    }
+  }
+
+  const headers = () => ({
+    accept: 'application/json',
+    ...(resolvedPassword === undefined
+      ? {}
+      : { authorization: basicAuth(username, resolvedPassword) }),
+  });
+
+  const request = async (method, pathname, { body, signal, directory, timeout } = {}) => {
+    const url = new URL(`${normalizedBaseUrl}${pathname}`);
+    if (typeof directory === 'string' && directory.length > 0) {
+      url.searchParams.set('directory', directory);
+    }
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        method,
+        headers: {
+          ...headers(),
+          ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+        },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        redirect: 'error',
+        signal: combineSignals(signal, timeout ?? timeoutMs),
+      });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      const message = error instanceof Error ? error.message : 'request failed';
+      throw new ExecutorError(`OpenCode request failed: ${message}`);
+    }
+    const bytes = await readResponseBytes(
+      response,
+      response.ok ? MAX_RESPONSE_BYTES : MAX_ERROR_BYTES,
+    );
+    if (!response.ok) {
+      throw new ExecutorError(`OpenCode returned HTTP ${response.status}`, {
+        status: response.status,
+      });
+    }
+    if (bytes.length === 0) return {};
+    try {
+      return JSON.parse(bytes.toString('utf8'));
+    } catch {
+      throw new ExecutorError('OpenCode returned invalid JSON');
+    }
+  };
+
+  const abortSession = async (sessionId, directory) => {
+    try {
+      await request('POST', `/session/${encodeURIComponent(sessionId)}/abort`, {
+        directory,
+        timeout: 5_000,
+      });
+    } catch {
+      // Best-effort cancellation; the original failure is preserved by the caller.
+    }
+  };
+
+  const execute = async (request_, { signal, directory } = {}) => {
+    const value = asObject(request_);
+    if (!value) throw new ExecutorError('generation request is invalid');
+    const output = Array.isArray(value.output) ? value.output : ['text'];
+    const wantsText = output.includes('text');
+    const wantsImage = output.includes('image');
+    if (wantsImage && !imageAdapter) {
+      throw new ExecutorError('image output was requested but no image adapter is configured');
+    }
+
+    let text;
+    let generatedAt = now();
+    let usage;
+    let model = value.model;
+
+    if (wantsText) {
+      const session = asObject(await request('POST', '/session', { signal, directory }));
+      const sessionId = boundedString(session?.id, 160, 'OpenCode session id');
+      try {
+        const reference = modelReference(value.model, providerID);
+        const body = {
+          parts: partsFromInput(value),
+          ...(reference === undefined ? {} : { model: reference }),
+          ...(value.outputSchema === undefined
+            ? {}
+            : {
+                format: {
+                  type: 'json_schema',
+                  schema: value.outputSchema.schema,
+                  retryCount: 2,
+                },
+              }),
+        };
+        const response = asObject(
+          await request('POST', `/session/${encodeURIComponent(sessionId)}/message`, {
+            body,
+            signal,
+            directory,
+          }),
+        );
+        const info = asObject(response?.info);
+        if (info?.error) {
+          const message = asObject(info.error)?.data;
+          throw new ExecutorError(
+            `OpenCode turn failed: ${asObject(message)?.message ?? info.error.name ?? 'unknown error'}`,
+          );
+        }
+        const structured = info?.structured_output;
+        text =
+          structured === undefined ? textFromParts(response?.parts) : JSON.stringify(structured);
+        model = value.model ?? info?.modelID;
+        const completed = info?.time?.completed;
+        generatedAt = Number.isInteger(completed) ? completed : generatedAt;
+        usage = usageFromTokens(info?.tokens);
+      } catch (error) {
+        await abortSession(sessionId, directory);
+        throw error;
+      }
+    }
+
+    const outputParts = [];
+    if (wantsText) {
+      outputParts.push({ type: 'text', text: text ?? '' });
+    }
+    if (wantsImage) {
+      const image = await imageAdapter.generate({
+        prompt: promptText(value),
+        images: referenceImages(value),
+        signal,
+        name: 'image-0.png',
+      });
+      outputParts.push(image);
+    }
+    return {
+      output: outputParts,
+      model: model ?? 'unknown',
+      generatedAt,
+      ...(usage === undefined ? {} : { usage }),
+    };
+  };
+
+  const listModels = async () => {
+    const payload = asObject(await request('GET', '/config/providers'));
+    const providers = Array.isArray(payload?.providers) ? payload.providers : [];
+    const defaults = asObject(payload?.default) ?? {};
+    const models = [];
+    for (const provider of providers) {
+      const providerId = provider?.id;
+      const providerModels = asObject(provider?.models);
+      if (typeof providerId !== 'string' || !providerModels) continue;
+      for (const [key, model] of Object.entries(providerModels)) {
+        const modelId = typeof model?.id === 'string' && model.id.length > 0 ? model.id : key;
+        const inputModalities = ['text'];
+        if (model?.capabilities?.input?.image === true) inputModalities.push('image');
+        models.push({
+          id: `${providerId}/${modelId}`,
+          inputModalities,
+          outputModalities: ['text'],
+          supportedReasoningEfforts: [DEFAULT_REASONING_EFFORT],
+          defaultReasoningEffort: DEFAULT_REASONING_EFFORT,
+          webSearch: false,
+          prefer: ['quality'],
+          isDefault: defaults[providerId] === modelId,
+          imageGeneration: imageAdapter !== undefined,
+        });
+      }
+    }
+    return models;
+  };
+
+  const health = async () => {
+    const payload = asObject(await request('GET', '/global/health', { timeout: 15_000 }));
+    if (payload?.healthy !== true) {
+      throw new ExecutorError('OpenCode server is not healthy');
+    }
+    return {
+      healthy: true,
+      ...(typeof payload.version === 'string' ? { version: payload.version } : {}),
+    };
+  };
+
+  return { name: 'opencode', execute, listModels, health };
+};
+
+export { DEFAULT_OPENCODE_URL, DEFAULT_OPENCODE_USERNAME, ExecutorError, createOpenCodeExecutor };

package/runtime/image/adapter.mjs

@@ -0,0 +1,213 @@
+const DEFAULT_OPENAI_IMAGE_MODEL = 'gpt-image-1';
+const DEFAULT_OPENAI_IMAGE_URL = 'https://api.openai.com/v1/images/generations';
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
+const MAX_IMAGE_BYTES = 25 * 1024 * 1024;
+const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+/**
+ * @typedef {object} ImageGenerationRequest
+ * @property {string} prompt Prompt describing the image to generate.
+ * @property {Array<{ mimeType: string, data: string, name?: string }>} [images] Optional
+ *   base64 reference images. Providers that cannot accept references reject them.
+ * @property {AbortSignal} [signal] Cancels the generation request.
+ * @property {string} [size] Provider size token.
+ * @property {string} [quality] Provider quality token.
+ * @property {string} [name] Preferred artifact name.
+ */
+
+/**
+ * @typedef {object} ImageAdapter
+ * @property {string} name Provider identifier.
+ * @property {(request: ImageGenerationRequest) => Promise<{
+ *   type: 'image',
+ *   mimeType: string,
+ *   data: string,
+ *   name?: string,
+ * }>} generate Generate a single image as a base64 AIPart.
+ */
+
+class ImageAdapterError extends Error {
+  constructor(message, { status } = {}) {
+    super(message);
+    this.name = 'ImageAdapterError';
+    if (status !== undefined) this.status = status;
+  }
+}
+
+const readResponseBytes = async (response, maximum) => {
+  const contentLength = Number(response.headers.get('content-length'));
+  if (Number.isFinite(contentLength) && contentLength > maximum) {
+    throw new ImageAdapterError('image provider response exceeds its size limit');
+  }
+  if (!response.body) return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (;;) {
+      // eslint-disable-next-line no-await-in-loop -- response bytes must be bounded sequentially.
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = Buffer.from(value);
+      total += chunk.length;
+      if (total > maximum) {
+        // eslint-disable-next-line no-await-in-loop -- cancelling the reader is part of the bounded read.
+        await reader.cancel();
+        throw new ImageAdapterError('image provider response exceeds its size limit');
+      }
+      chunks.push(chunk);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total);
+};
+
+const combineSignals = (signal, timeoutMs) => {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  if (signal === undefined) return timeout;
+  return AbortSignal.any([signal, timeout]);
+};
+
+const decodeImage = (value, name) => {
+  if (typeof value !== 'string' || value.length === 0 || !BASE64.test(value)) {
+    throw new ImageAdapterError('image provider returned invalid base64 data');
+  }
+  const bytes = Buffer.from(value, 'base64');
+  if (bytes.length === 0 || bytes.length > MAX_IMAGE_BYTES) {
+    throw new ImageAdapterError('image provider returned an image outside its size limit');
+  }
+  if (bytes.toString('base64') !== value) {
+    throw new ImageAdapterError('image provider returned non-canonical base64 data');
+  }
+  if (
+    bytes.length < PNG_SIGNATURE.length ||
+    !bytes.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)
+  ) {
+    throw new ImageAdapterError('image provider returned data that is not a PNG');
+  }
+  return { type: 'image', mimeType: 'image/png', data: value, name };
+};
+
+/**
+ * OpenAI Images adapter. Returns base64 PNG data as an AIPart. The OpenAI Images
+ * API does not accept input reference images, so requests carrying references
+ * are rejected rather than silently ignored.
+ *
+ * @param {{
+ *   apiKey: string,
+ *   fetch?: typeof globalThis.fetch,
+ *   model?: string,
+ *   url?: string,
+ *   timeoutMs?: number,
+ *   size?: string,
+ *   quality?: string,
+ * }} options
+ * @returns {ImageAdapter}
+ */
+const createOpenAIImageAdapter = ({
+  apiKey,
+  fetch: fetchImpl = globalThis.fetch,
+  model = DEFAULT_OPENAI_IMAGE_MODEL,
+  url = DEFAULT_OPENAI_IMAGE_URL,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  size,
+  quality,
+} = {}) => {
+  if (typeof apiKey !== 'string' || apiKey.trim().length === 0) {
+    throw new ImageAdapterError('image provider API key is required');
+  }
+  if (typeof fetchImpl !== 'function') {
+    throw new ImageAdapterError('image provider fetch implementation is required');
+  }
+  let endpoint;
+  try {
+    endpoint = new URL(url).toString();
+  } catch {
+    throw new ImageAdapterError('image provider URL is invalid');
+  }
+
+  const generate = async ({
+    prompt,
+    images = [],
+    signal,
+    size: requestSize,
+    quality: requestQuality,
+    name,
+  } = {}) => {
+    if (typeof prompt !== 'string' || prompt.trim().length === 0) {
+      throw new ImageAdapterError('image prompt is required');
+    }
+    if (!Array.isArray(images)) {
+      throw new ImageAdapterError('image references must be an array');
+    }
+    if (images.length > 0) {
+      throw new ImageAdapterError('OpenAI image generation does not accept input reference images');
+    }
+
+    const body = {
+      model,
+      prompt,
+      n: 1,
+      ...((requestSize ?? size) === undefined ? {} : { size: requestSize ?? size }),
+      ...((requestQuality ?? quality) === undefined ? {} : { quality: requestQuality ?? quality }),
+    };
+    const requestSignal = combineSignals(signal, timeoutMs);
+    let response;
+    try {
+      response = await fetchImpl(endpoint, {
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${apiKey.trim()}`,
+          'content-type': 'application/json',
+          accept: 'application/json',
+        },
+        body: JSON.stringify(body),
+        redirect: 'error',
+        signal: requestSignal,
+      });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      const message = error instanceof Error ? error.message : 'image request failed';
+      throw new ImageAdapterError(`image provider request failed: ${message}`);
+    }
+    const bytes = await readResponseBytes(response, response.ok ? MAX_RESPONSE_BYTES : 16 * 1024);
+    if (!response.ok) {
+      throw new ImageAdapterError(`image provider returned HTTP ${response.status}`, {
+        status: response.status,
+      });
+    }
+    let payload;
+    try {
+      payload = JSON.parse(bytes.toString('utf8'));
+    } catch {
+      throw new ImageAdapterError('image provider returned invalid JSON');
+    }
+    const first = Array.isArray(payload?.data) ? payload.data[0] : undefined;
+    const encoded = first?.b64_json;
+    return decodeImage(encoded, typeof name === 'string' && name.length > 0 ? name : 'image-0.png');
+  };
+
+  return { name: 'openai', generate };
+};
+
+/**
+ * Select an image adapter by provider name.
+ *
+ * @param {{ provider?: string } & Parameters<typeof createOpenAIImageAdapter>[0]} options
+ * @returns {ImageAdapter}
+ */
+const createImageAdapter = ({ provider = 'openai', ...options } = {}) => {
+  if (provider === 'openai') return createOpenAIImageAdapter(options);
+  throw new ImageAdapterError(`unsupported image provider: ${provider}`);
+};
+
+export {
+  DEFAULT_OPENAI_IMAGE_MODEL,
+  DEFAULT_OPENAI_IMAGE_URL,
+  ImageAdapterError,
+  createImageAdapter,
+  createOpenAIImageAdapter,
+};

package/runtime/index.mjs

@@ -0,0 +1,53 @@
+/* eslint-disable import/extensions -- Native Node ESM requires file extensions. */
+
+export {
+  GENERATION_VERSION,
+  GenerationProtocolError,
+  idempotencyDigest,
+  normalizeGenerationRequest,
+  normalizeIdempotencyKey,
+  normalizeModelCatalog,
+  publicModelCatalog,
+  requestDigest,
+  toRunnerInput,
+} from './protocol.mjs';
+export { GenerationStore, GenerationStoreError } from './store.mjs';
+export {
+  DEFAULT_GENERATION_PORT,
+  GenerationServer,
+  createLocalRunner,
+  isAllowedPeer,
+  normalizeBindHost,
+  startGenerationServer,
+} from './server.mjs';
+export {
+  ANALYTICA_EVENT_URL,
+  DEFAULT_ANALYTICA_EVENT_PREFIX,
+  DEFAULT_ANALYTICA_PAGE_LOCATION,
+  AnalyticaEvents,
+  analyticaEventName,
+} from './telemetry.mjs';
+export {
+  DEFAULT_OPENCODE_URL,
+  DEFAULT_OPENCODE_USERNAME,
+  ExecutorError,
+  createOpenCodeExecutor,
+} from './executor/opencode.mjs';
+export {
+  DEFAULT_OPENAI_IMAGE_MODEL,
+  DEFAULT_OPENAI_IMAGE_URL,
+  ImageAdapterError,
+  createImageAdapter,
+  createOpenAIImageAdapter,
+} from './image/adapter.mjs';
+export {
+  JobError,
+  RunnerClient,
+  RunnerHttpError,
+  UncertainRequestError,
+  createCancellation,
+  normalizeBaseUrl,
+  processJob,
+  readConfig,
+  validateJobEnvelope,
+} from './bridge.mjs';