@skaile/workspaces 3.27.0 → 4.0.0

package/dist/chunk-SG4D2UOK.js

@@ -0,0 +1,843 @@
+import { pluginRegistry } from './chunk-6E6PKKAD.js';
+import { resolveCredential } from './chunk-KSIRR5PL.js';
+import { AI_PROVIDER_BASE_URL_TEMPLATES, resolveEntryBaseUrl, parseCredentialRef, registryEntries, isEntryEnabled, mergeRegistries } from './chunk-ILG4BXYE.js';
+import { createLogger } from './chunk-W4IPN3DD.js';
+import { EventEmitter } from 'events';
+
+// bridge/src/logger.ts
+function getBridgeLogger(subkind) {
+  return createLogger({ kind: "bridge", subkind });
+}
+
+// bridge/src/provider-catalog.ts
+var ANTHROPIC_VERSION_HEADER = { "anthropic-version": "2023-06-01" };
+var X_API_KEY = { name: "x-api-key", template: "{credential}" };
+var OPENAI_MODELS_PATH = "/v1/models";
+var AI_PROVIDER_PRESETS = {
+  anthropic: {
+    id: "anthropic",
+    kind: "llm",
+    label: "Anthropic",
+    surface: "anthropic-messages",
+    base_url: "https://api.anthropic.com",
+    base_url_env: "ANTHROPIC_BASE_URL",
+    headers: ANTHROPIC_VERSION_HEADER,
+    credential: { kind: "api_key_header", env: "ANTHROPIC_API_KEY" },
+    auth_header: X_API_KEY,
+    probe_path: "/v1/models",
+    discovery: { type: "anthropic-models-list" }
+  },
+  openai: {
+    id: "openai",
+    kind: "llm",
+    label: "OpenAI",
+    surface: "openai-responses",
+    base_url: "https://api.openai.com/v1",
+    base_url_env: "OPENAI_BASE_URL",
+    credential: { kind: "bearer", env: "OPENAI_API_KEY" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" },
+    notes: "Responses is OpenAI's current API; set surface openai-completions for chat-only clients."
+  },
+  google: {
+    id: "google",
+    kind: "llm",
+    label: "Google Gemini API",
+    surface: "google-generative-ai",
+    base_url: "https://generativelanguage.googleapis.com/v1beta",
+    credential: { kind: "api_key_header", env: "GEMINI_API_KEY" },
+    auth_header: { name: "x-goog-api-key", template: "{credential}" },
+    probe_path: "/v1beta/models",
+    discovery: { type: "google-models-list" }
+  },
+  groq: {
+    id: "groq",
+    kind: "llm",
+    label: "Groq",
+    surface: "openai-completions",
+    base_url: "https://api.groq.com/openai/v1",
+    credential: { kind: "bearer", env: "GROQ_API_KEY" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" }
+  },
+  deepseek: {
+    id: "deepseek",
+    kind: "llm",
+    label: "DeepSeek",
+    surface: "openai-completions",
+    base_url: "https://api.deepseek.com",
+    credential: { kind: "bearer", env: "DEEPSEEK_API_KEY" },
+    probe_path: "/models",
+    discovery: { type: "openai-models-list" },
+    notes: "Anthropic-shaped clients use https://api.deepseek.com/anthropic with surface anthropic-messages."
+  },
+  openrouter: {
+    id: "openrouter",
+    kind: "llm",
+    label: "OpenRouter",
+    surface: "openai-completions",
+    base_url: "https://openrouter.ai/api/v1",
+    credential: { kind: "bearer", env: "OPENROUTER_API_KEY" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" }
+  },
+  mistral: {
+    id: "mistral",
+    kind: "llm",
+    label: "Mistral",
+    surface: "openai-completions",
+    base_url: "https://api.mistral.ai/v1",
+    credential: { kind: "bearer", env: "MISTRAL_API_KEY" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" }
+  },
+  xai: {
+    id: "xai",
+    kind: "llm",
+    label: "xAI (Grok)",
+    surface: "openai-completions",
+    base_url: "https://api.x.ai/v1",
+    credential: { kind: "bearer", env: "XAI_API_KEY" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" }
+  },
+  together: {
+    id: "together",
+    kind: "llm",
+    label: "Together AI",
+    surface: "openai-completions",
+    base_url: "https://api.together.ai/v1",
+    credential: { kind: "bearer", env: "TOGETHER_API_KEY" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" }
+  },
+  fireworks: {
+    id: "fireworks",
+    kind: "llm",
+    label: "Fireworks AI",
+    surface: "openai-completions",
+    base_url: "https://api.fireworks.ai/inference/v1",
+    credential: { kind: "bearer", env: "FIREWORKS_API_KEY" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" }
+  },
+  bedrock: {
+    id: "bedrock",
+    kind: "llm",
+    label: "AWS Bedrock",
+    surface: "bedrock-converse-stream",
+    transport: "bedrock",
+    credential: { kind: "sigv4" },
+    required_params: ["region"],
+    notes: "Credentials come from the AWS default chain; the runtime host serves no models list."
+  },
+  vertex: {
+    id: "vertex",
+    kind: "llm",
+    label: "Google Vertex AI",
+    surface: "google-vertex",
+    transport: "vertex",
+    credential: { kind: "google_adc" },
+    params: { publisher: "google" },
+    required_params: ["project", "location"],
+    probe_path: "/models"
+  },
+  "azure-openai": {
+    id: "azure-openai",
+    kind: "llm",
+    label: "Azure OpenAI",
+    surface: "azure-openai-responses",
+    transport: "azure-openai",
+    credential: { kind: "api_key_header", env: "AZURE_OPENAI_API_KEY" },
+    auth_header: { name: "api-key", template: "{credential}" },
+    required_params: ["resource", "deployment", "api_version"],
+    probe_path: "/models",
+    notes: "api_version is mirrored into query_params['api-version']; switch credential.kind to azure_entra for Entra tokens."
+  },
+  foundry: {
+    id: "foundry",
+    kind: "llm",
+    label: "Claude on Microsoft Foundry",
+    surface: "anthropic-messages",
+    transport: "foundry",
+    headers: ANTHROPIC_VERSION_HEADER,
+    credential: { kind: "api_key_header", env: "ANTHROPIC_FOUNDRY_API_KEY" },
+    auth_header: X_API_KEY,
+    required_params: ["resource"],
+    probe_path: "/v1/models"
+  },
+  ollama: {
+    id: "ollama",
+    kind: "llm",
+    label: "Ollama (local)",
+    surface: "openai-completions",
+    base_url: "http://localhost:11434/v1",
+    credential: { kind: "none" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" }
+  },
+  lmstudio: {
+    id: "lmstudio",
+    kind: "llm",
+    label: "LM Studio (local)",
+    surface: "openai-completions",
+    base_url: "http://localhost:1234/v1",
+    credential: { kind: "none" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" }
+  },
+  vllm: {
+    id: "vllm",
+    kind: "llm",
+    label: "vLLM (self-hosted)",
+    surface: "openai-completions",
+    base_url: "http://localhost:8000/v1",
+    credential: { kind: "none" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" },
+    notes: "A server started with --api-key expects credential.kind bearer and an env: ref."
+  },
+  litellm: {
+    id: "litellm",
+    kind: "llm",
+    label: "LiteLLM proxy",
+    surface: "openai-completions",
+    base_url: "http://localhost:4000",
+    credential: { kind: "bearer", env: "LITELLM_API_KEY" },
+    probe_path: OPENAI_MODELS_PATH,
+    discovery: { type: "openai-models-list" },
+    notes: "The credential is the proxy's virtual key; upstream keys stay in the proxy config."
+  },
+  deepgram: {
+    id: "deepgram",
+    kind: "stt",
+    label: "Deepgram",
+    base_url: "https://api.deepgram.com",
+    credential: { kind: "api_key_header", env: "DEEPGRAM_API_KEY" },
+    auth_header: { name: "Authorization", template: "Token {credential}" },
+    params: { model: "nova-3", language: "en" },
+    probe_path: "/v1/projects"
+  },
+  elevenlabs: {
+    id: "elevenlabs",
+    kind: "tts",
+    label: "ElevenLabs",
+    base_url: "https://api.elevenlabs.io",
+    credential: { kind: "api_key_header", env: "ELEVENLABS_API_KEY" },
+    auth_header: { name: "xi-api-key", template: "{credential}" },
+    params: { voice_id: "21m00Tcm4TlvDq8ikWAM", output_format: "mp3_44100_128" },
+    probe_path: "/v1/models"
+  }
+};
+function listProviderPresets() {
+  return Object.values(AI_PROVIDER_PRESETS);
+}
+function getProviderPreset(id) {
+  return AI_PROVIDER_PRESETS[id];
+}
+function presetBaseUrl(preset) {
+  if (preset.base_url) return preset.base_url;
+  if (!preset.transport || preset.transport === "direct") return void 0;
+  return AI_PROVIDER_BASE_URL_TEMPLATES[preset.transport];
+}
+function resolvePresetBaseUrl(preset, options = {}) {
+  const explicit = options.baseUrl?.trim();
+  if (explicit) return explicit;
+  const fromEnv = preset.base_url_env ? options.env?.[preset.base_url_env]?.trim() : void 0;
+  return fromEnv || preset.base_url;
+}
+function expandPreset(preset, options = {}) {
+  const ref = options.credentialRef ?? (preset.credential.env ? `env:${preset.credential.env}` : void 0);
+  const credential = ref ? { kind: preset.credential.kind, ref } : { kind: preset.credential.kind };
+  const base_url = options.baseUrl ?? preset.base_url;
+  const params = { ...preset.params, ...options.params };
+  if (preset.kind === "stt" || preset.kind === "tts") {
+    return {
+      kind: preset.kind,
+      label: options.label ?? preset.label,
+      preset: preset.id,
+      ...base_url ? { base_url } : {},
+      ...preset.headers ? { headers: { ...preset.headers } } : {},
+      credential,
+      ...Object.keys(params).length > 0 ? { params } : {}
+    };
+  }
+  const transport = preset.transport ?? "direct";
+  const entry = {
+    kind: preset.kind === "embed" ? "embed" : "llm",
+    label: options.label ?? preset.label,
+    preset: preset.id,
+    ...options.surface ?? preset.surface ? { surface: options.surface ?? preset.surface } : {},
+    ...base_url ? { base_url } : {},
+    ...preset.headers ? { headers: { ...preset.headers } } : {},
+    credential,
+    ...preset.discovery ? { discovery: { ...preset.discovery } } : {}
+  };
+  if (transport !== "direct") {
+    Object.assign(entry, { transport, params });
+    if (transport === "azure-openai" && params.api_version) {
+      entry.query_params = { "api-version": params.api_version };
+    }
+  }
+  return entry;
+}
+function catalogLayer(providers) {
+  const expanded = {};
+  for (const [id, entry] of Object.entries(providers)) {
+    if (!entry.preset) continue;
+    const preset = AI_PROVIDER_PRESETS[entry.preset];
+    if (!preset) continue;
+    expanded[id] = expandPreset(preset);
+  }
+  return { layer: "catalog", providers: expanded };
+}
+function joinBaseAndPath(base, path) {
+  const trimmed = base.replace(/\/+$/, "");
+  const segments = path.split("/").filter(Boolean);
+  const lead = segments[0];
+  if (lead && trimmed.toLowerCase().endsWith(`/${lead.toLowerCase()}`)) {
+    return `${trimmed}/${segments.slice(1).join("/")}`;
+  }
+  return `${trimmed}${path}`;
+}
+function resolveProbeUrl(entry) {
+  const base = resolveEntryBaseUrl(entry);
+  if (!base) return void 0;
+  const preset = entry.preset ? AI_PROVIDER_PRESETS[entry.preset] : void 0;
+  const path = entry.discovery?.path ?? preset?.probe_path;
+  if (!path) return void 0;
+  const url = joinBaseAndPath(base, path);
+  const query = entry.query_params;
+  if (!query || Object.keys(query).length === 0) return url;
+  const search = new URLSearchParams(query).toString();
+  return `${url}${url.includes("?") ? "&" : "?"}${search}`;
+}
+function buildCredentialHeaders(entry, secret) {
+  const kind = entry.credential?.kind ?? "none";
+  if (!secret || kind === "none" || kind === "sigv4" || kind === "google_adc") return {};
+  const preset = entry.preset ? AI_PROVIDER_PRESETS[entry.preset] : void 0;
+  if (preset?.auth_header) {
+    return {
+      [preset.auth_header.name]: preset.auth_header.template.replace("{credential}", secret)
+    };
+  }
+  if (kind === "api_key_header") {
+    const surface = entry.surface;
+    if (surface === "google-generative-ai") return { "x-goog-api-key": secret };
+    if (surface === "azure-openai-responses") return { "api-key": secret };
+    return { "x-api-key": secret };
+  }
+  return { Authorization: `Bearer ${secret}` };
+}
+async function probeProviderEntry(entry, options = {}) {
+  const url = resolveProbeUrl(entry);
+  if (!url) {
+    const base = resolveEntryBaseUrl(entry);
+    return {
+      ok: false,
+      probed: false,
+      detail: base ? `no read-only probe endpoint is defined for this entry (${base})` : "no base_url could be resolved \u2014 set base_url or the transport's params"
+    };
+  }
+  const headers = {
+    ...entry.headers,
+    ...buildCredentialHeaders(entry, options.secret)
+  };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 8e3);
+  try {
+    const response = await fetch(url, { method: "GET", headers, signal: controller.signal });
+    if (response.ok) {
+      return { ok: true, probed: true, url, status: response.status, detail: "endpoint reachable" };
+    }
+    const detail = response.status === 401 || response.status === 403 ? "credential rejected (authentication failed)" : `endpoint returned HTTP ${response.status}`;
+    return { ok: false, probed: true, url, status: response.status, detail };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const detail = err instanceof Error && err.name === "AbortError" ? `request timed out after ${options.timeoutMs ?? 8e3}ms` : message;
+    return { ok: false, probed: true, url, detail };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// bridge/src/provider-materialize/credential-env.ts
+var PROVIDER_CREDENTIAL_ENV_PREFIX = "SKAILE_AIP_";
+var PROVIDER_CREDENTIAL_ENV_SUFFIX = "_KEY";
+function providerCredentialEnvName(providerId) {
+  const slug = providerId.replace(/[^A-Za-z0-9]/g, "_").toUpperCase();
+  return `${PROVIDER_CREDENTIAL_ENV_PREFIX}${slug}${PROVIDER_CREDENTIAL_ENV_SUFFIX}`;
+}
+function conventionalCredentialEnvName(entry) {
+  const preset = entry.preset ? AI_PROVIDER_PRESETS[entry.preset] : void 0;
+  if (preset?.credential.env) return preset.credential.env;
+  const ref = entry.credential?.ref ? parseCredentialRef(entry.credential.ref) : void 0;
+  return ref?.form === "env" ? ref.name : void 0;
+}
+function resolveEntryCredential(entry, options = {}) {
+  return resolveCredential(entry, {
+    ...options.env ? { env: options.env } : {},
+    ...options.secrets ? { secrets: options.secrets } : {},
+    ...options.allowCommand === void 0 ? {} : { allowCommand: options.allowCommand }
+  }).value;
+}
+function entryCredentialValue(providerId, entry, options = {}) {
+  return resolveEntryCredential(entry, options) ?? options.env?.[providerCredentialEnvName(providerId)];
+}
+function entryCredentialEnv(providerId, entry, options = {}) {
+  const value = resolveEntryCredential(entry, options);
+  if (!value) return {};
+  const out = { [providerCredentialEnvName(providerId)]: value };
+  if (options.aliases !== false) {
+    const alias = conventionalCredentialEnvName(entry);
+    if (alias) out[alias] = value;
+  }
+  return out;
+}
+function registryCredentialEnv(registry, options = {}) {
+  const canonical = {};
+  const aliases = {};
+  for (const [id, entry] of registryEntries(registry)) {
+    if (options.providerId && id !== options.providerId) continue;
+    if (!isEntryEnabled(entry)) continue;
+    const value = resolveEntryCredential(entry, options);
+    if (!value) continue;
+    canonical[providerCredentialEnvName(id)] = value;
+    if (options.aliases === false) continue;
+    const alias = conventionalCredentialEnvName(entry);
+    if (alias && aliases[alias] === void 0) aliases[alias] = value;
+  }
+  return { ...aliases, ...canonical };
+}
+
+// bridge/src/provider-registry-derive.ts
+var PRESET_ALIASES = { gemini: "google" };
+function toMergedRegistry(registry, layer = "session") {
+  if (Array.isArray(registry.order)) {
+    return registry;
+  }
+  return mergeRegistries([{ layer, providers: registry }]);
+}
+function slugProviderId(provider) {
+  const slug = provider.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[^a-z0-9]+/, "");
+  return slug || "provider";
+}
+function deriveApiKeyEntry(provider, literal, env, credentialEnv) {
+  const preset = AI_PROVIDER_PRESETS[PRESET_ALIASES[provider] ?? provider];
+  const envBaseUrl = preset?.base_url_env ? env[preset.base_url_env]?.trim() : void 0;
+  const baseUrl = envBaseUrl || preset?.base_url;
+  const envNames = [
+    preset?.credential.env,
+    `${provider.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`
+  ].filter((name) => !!name);
+  const envName = envNames.find((name) => env[name]) ?? envNames[0];
+  credentialEnv[envName] = literal;
+  const credential = {
+    kind: preset?.credential.kind ?? "bearer",
+    ref: `env:${envName}`
+  };
+  return {
+    kind: "llm",
+    label: preset?.label ?? provider,
+    // `openai-completions` is the only defensible guess for a provider the
+    // catalog has never heard of: every unlisted vendor the settings cascade
+    // accepts today speaks the OpenAI chat wire format.
+    surface: preset?.surface ?? "openai-completions",
+    ...baseUrl ? { base_url: baseUrl } : {},
+    ...preset?.headers ? { headers: { ...preset.headers } } : {},
+    ...preset?.discovery ? { discovery: { ...preset.discovery } } : {},
+    credential
+  };
+}
+function deriveRegistryFromLegacyApiKeys(apiKeys, options = {}) {
+  const env = options.env ?? process.env;
+  const providers = {};
+  const credentialEnv = {};
+  for (const [provider, key] of Object.entries(apiKeys ?? {})) {
+    if (!key) continue;
+    providers[slugProviderId(provider)] = deriveApiKeyEntry(provider, key, env, credentialEnv);
+  }
+  const ids = Object.keys(providers);
+  if (ids.length === 0) return { providers, credentialEnv };
+  return {
+    providers,
+    credentialEnv,
+    deprecation: `[ai-provider-registry] settings.json apiKeys{} is legacy \u2014 normalized ${ids.join(", ")} into registry entries whose credential is an env: reference. Define these endpoints once with 'skaile providers add <id> --preset <preset>' (~/.skaile/providers.yml) and drop apiKeys; it is removed in the next major.`
+  };
+}
+function registryDriverConfig(registry, options = {}) {
+  const merged = toMergedRegistry(registry, "runtime");
+  return {
+    registry: merged,
+    env: registryCredentialEnv(merged, options),
+    ...options.providerId ? { modelRef: options.providerId } : {}
+  };
+}
+var AgentDriver = class extends EventEmitter {
+  /** Preserve text-only callers; drivers must explicitly support attachments. */
+  promptInput(input) {
+    if (input.attachments?.length) return Promise.reject(new Error("Structured input unsupported"));
+    return this.prompt(input.text);
+  }
+  /** Managed replies never fall back to a new prompt after a request has settled. */
+  get acceptsReplyAsPrompt() {
+    return true;
+  }
+  /** Stop the driver and await owned process/state cleanup when the backend supports it. */
+  async dispose() {
+    this.kill();
+  }
+  /** Optional provider-native session/thread identifier for resume support. */
+  get runtimeSessionId() {
+    return void 0;
+  }
+  /** Slash commands discovered from the agent runtime. Override in drivers that support introspection. */
+  getSlashCommands() {
+    return [];
+  }
+  // ── Interactive questions (AskUserQuestion) ──────────────────────────────
+  /**
+   * `true` while the driver is paused on an interactive question and waiting
+   * for the user's answer rather than a new prompt. The runner routes a
+   * `reply` command to {@link answerQuestion} instead of {@link prompt} when
+   * this returns `true`. Drivers without interactive-question support return
+   * `false` (the default), so a `reply` falls back to `prompt`.
+   */
+  hasPendingQuestion() {
+    return false;
+  }
+  /**
+   * Deliver the user's answer to the question the driver is currently paused
+   * on. This resumes the in-flight turn — it does NOT start a new one. When a
+   * single tool call asks several questions, the driver resolves the underlying
+   * call only once every sub-question has an answer.
+   *
+   * @param answer - The user's reply text (an option label, free text, or for
+   *   multi-select a comma-joined list).
+   * @param question - The sub-question this answers, verbatim from the
+   *   `question` event that asked it. Supply it whenever the host lets the user
+   *   answer out of order — without it the answer fills the next unanswered
+   *   slot in order, which silently mismatches a non-sequential reply.
+   * @returns `true` when the answer was consumed by a pending question; `false`
+   *   when no question was pending (caller should treat the reply as a prompt).
+   */
+  answerQuestion(answer, question, requestId) {
+    return false;
+  }
+  // ── Live reconfiguration ────────────────────────────────────────────────
+  /**
+   * Live-update driver configuration. The new values take effect on the next
+   * prompt() call. Only model/thinking/effort are reconfigurable mid-session.
+   *
+   * Subclasses that store config locally should override this to apply the
+   * patch to their own config field. The base implementation is a no-op.
+   */
+  reconfigure(patch) {
+  }
+  /**
+   * Returns the model identifier currently configured on this driver.
+   * Subclasses that store config locally should override this.
+   */
+  getModel() {
+    return void 0;
+  }
+  // ── Compaction support ──────────────────────────────────────────────────
+  /**
+   * Returns the token usage from the most recent completed turn.
+   * Returns `null` if usage data is unavailable (e.g. driver doesn't track it).
+   *
+   * Widened in 3.1.0 to return the full `TokenUsage` shape (input / output /
+   * cache-read / cache-creation / reasoning). All fields are optional so
+   * drivers can populate just what their provider reports. Existing callers
+   * that read only `inputTokens` / `outputTokens` keep working — those fields
+   * are still present and carry the same semantics as before.
+   */
+  getTokenUsage() {
+    return null;
+  }
+  /**
+   * Prompt tokens occupying the context window as of the most recent API
+   * request — i.e. how full the context actually is right now.
+   *
+   * Deliberately NOT the same number as {@link getTokenUsage}, whose usage is
+   * cumulative over every API call in the turn and therefore overstates the
+   * context by 10-40x on any multi-tool turn. Callers measuring context fill
+   * (compaction thresholds) must prefer this; callers billing a turn
+   * (usage ledgers, the `finished` event) must keep using `getTokenUsage()`.
+   *
+   * Returns `null` both when the driver cannot report a per-call figure at all
+   * and when it can but has no reading yet. Falling back to `getTokenUsage()`
+   * is safe in either case only because a driver clears the two in lockstep: no
+   * reading means no API call landed, so there is no cumulative usage to
+   * overstate. A driver implementing this must preserve that invariant.
+   */
+  getContextTokens() {
+    return null;
+  }
+  /**
+   * Returns the model's context window size in tokens.
+   * Returns `null` if unknown.
+   */
+  getContextWindow() {
+    return null;
+  }
+  /**
+   * Returns the list of models available to this driver without starting a session.
+   * Drivers that can enumerate their own models override this method.
+   * Returns an empty array by default.
+   */
+  async listModels() {
+    return [];
+  }
+  // ── Telemetry ─────────────────────────────────────────────────────────────
+  _telemetry;
+  _activeTrace;
+  _activeTurnSpan;
+  _turnStartTime;
+  /**
+   * Attach a telemetry provider and active trace to this driver.
+   * Called by the runner after creating the driver but before start().
+   */
+  setTelemetry(provider, trace) {
+    this._telemetry = provider;
+    this._activeTrace = trace;
+  }
+  /**
+   * Begin a turn span. Called by the runner before prompt().
+   * Pass a parent span (e.g. the turn span from the orchestrator) for nesting.
+   * Returns the span so the runner can annotate it further.
+   */
+  beginTurnSpan(parent, attrs) {
+    if (!this._telemetry || !this._activeTrace) return void 0;
+    this._turnStartTime = Date.now();
+    this._activeTurnSpan = this._telemetry.startSpan(parent ?? this._activeTrace, {
+      name: "llm_generation",
+      kind: "llm_generation",
+      attributes: attrs
+    });
+    return this._activeTurnSpan;
+  }
+  /**
+   * End the current turn span with generation data.
+   * Called by the runner after agent_end. Model and provider are passed
+   * explicitly — the driver base class does not access config directly.
+   */
+  endTurnSpan(result) {
+    if (!this._telemetry || !this._activeTurnSpan) return;
+    const durationMs = this._turnStartTime ? Date.now() - this._turnStartTime : 0;
+    if (result?.inputTokens !== void 0 || result?.outputTokens !== void 0) {
+      this._telemetry.logGeneration(this._activeTurnSpan, {
+        model: result?.model ?? "unknown",
+        provider: result?.provider ?? "unknown",
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        durationMs,
+        stopReason: result.stopReason
+      });
+    }
+    this._telemetry.endSpan(this._activeTurnSpan, {
+      status: result?.error ? "error" : "ok",
+      error: result?.error,
+      attributes: { "skaile.turn.duration_ms": durationMs }
+    });
+    this._activeTurnSpan = void 0;
+    this._turnStartTime = void 0;
+  }
+};
+
+// bridge/src/registry.ts
+var INCLUDE_CLAUDE_SDK = typeof __INCLUDE_CLAUDE_SDK__ === "undefined" ? true : __INCLUDE_CLAUDE_SDK__;
+var INCLUDE_CODEX = typeof __INCLUDE_CODEX__ === "undefined" ? true : __INCLUDE_CODEX__;
+var OMP_SURFACES = [
+  "anthropic-messages",
+  "openai-completions",
+  "openai-responses",
+  "openai-codex-responses",
+  "azure-openai-responses",
+  "bedrock-converse-stream",
+  "google-generative-ai",
+  "google-vertex"
+];
+var BUILTIN_DRIVER_CATALOG = {
+  omp: {
+    id: "omp",
+    name: "omp (oh-my-pi)",
+    modelAgnostic: true,
+    supportsInBandAbort: true,
+    surfaces: OMP_SURFACES,
+    // omp renders the whole registry as its own `models.yml`, so every entry
+    // stays selectable and roles / per-subagent models resolve across them.
+    providerPlurality: "registry"
+  },
+  "claude-sdk": {
+    id: "claude-sdk",
+    name: "Claude Agent SDK",
+    modelAgnostic: false,
+    supportsInBandAbort: true,
+    // Anthropic's own API, plus the two clouds the SDK addresses natively.
+    // Foundry is `anthropic-messages` at a different host, not a surface.
+    surfaces: ["anthropic-messages", "bedrock-converse-stream", "google-vertex"],
+    providerPlurality: "single"
+  },
+  codex: {
+    id: "codex",
+    name: "OpenAI Codex",
+    modelAgnostic: false,
+    supportsInBandAbort: true,
+    // Codex's `wire_api` is `responses` or `chat`; its subscription transport
+    // is the codex-specific responses flavour.
+    surfaces: ["openai-codex-responses", "openai-responses", "openai-completions"],
+    providerPlurality: "single"
+  },
+  echo: {
+    id: "echo",
+    name: "Echo (E2E mock)",
+    modelAgnostic: true,
+    supportsInBandAbort: false,
+    // Deterministic mock: it never opens a connection, so it speaks no wire
+    // surface and no registry entry can be dispatched to it.
+    surfaces: [],
+    providerPlurality: "single"
+  },
+  gemini: {
+    id: "gemini",
+    name: "Gemini CLI",
+    modelAgnostic: false,
+    supportsInBandAbort: false,
+    surfaces: ["google-generative-ai"],
+    providerPlurality: "single"
+  },
+  qwen: {
+    id: "qwen",
+    name: "Qwen Code",
+    modelAgnostic: true,
+    supportsInBandAbort: false,
+    // Driven entirely through OPENAI_BASE_URL / OPENAI_API_KEY.
+    surfaces: ["openai-completions"],
+    providerPlurality: "single"
+  },
+  opencode: {
+    id: "opencode",
+    name: "OpenCode",
+    modelAgnostic: true,
+    supportsInBandAbort: false,
+    surfaces: [
+      "anthropic-messages",
+      "openai-completions",
+      "openai-responses",
+      "google-generative-ai"
+    ],
+    providerPlurality: "credentials-n"
+  },
+  goose: {
+    id: "goose",
+    name: "Goose",
+    modelAgnostic: true,
+    supportsInBandAbort: false,
+    surfaces: [
+      "anthropic-messages",
+      "openai-completions",
+      "google-generative-ai",
+      "bedrock-converse-stream"
+    ],
+    providerPlurality: "credentials-n"
+  },
+  continue: {
+    id: "continue",
+    name: "Continue CLI",
+    modelAgnostic: true,
+    supportsInBandAbort: false,
+    surfaces: ["anthropic-messages", "openai-completions", "google-generative-ai"],
+    providerPlurality: "credentials-n"
+  }
+};
+var DRIVER_CATALOG = BUILTIN_DRIVER_CATALOG;
+var _driversRegistered = false;
+async function registerBuiltinDrivers(registry = pluginRegistry) {
+  if (registry === pluginRegistry && _driversRegistered) return;
+  if (!registry.get("driver", "omp")) {
+    const m = await import('./bridge/drivers/omp.js');
+    registry.register("driver", m.ompDriverTarget);
+  }
+  if (!registry.get("driver", "echo")) {
+    const m = await import('./bridge/drivers/echo.js');
+    registry.register("driver", m.echoDriverTarget);
+  }
+  if (INCLUDE_CLAUDE_SDK && !registry.get("driver", "claude-sdk")) {
+    const m = await import('./bridge/drivers/claude-sdk.js');
+    registry.register("driver", m.claudeSdkDriverTarget);
+  }
+  if (INCLUDE_CODEX && !registry.get("driver", "codex")) {
+    const m = await import('./bridge/drivers/codex.js');
+    registry.register("driver", m.codexDriverTarget);
+  }
+  if (!registry.get("driver", "gemini")) {
+    const m = await import('./bridge/drivers/gemini.js');
+    registry.register("driver", m.geminiDriverTarget);
+  }
+  if (!registry.get("driver", "qwen")) {
+    const m = await import('./bridge/drivers/qwen.js');
+    registry.register("driver", m.qwenDriverTarget);
+  }
+  if (!registry.get("driver", "opencode")) {
+    const m = await import('./bridge/drivers/opencode.js');
+    registry.register("driver", m.opencodeDriverTarget);
+  }
+  if (!registry.get("driver", "goose")) {
+    const m = await import('./bridge/drivers/goose.js');
+    registry.register("driver", m.gooseDriverTarget);
+  }
+  if (!registry.get("driver", "continue")) {
+    const m = await import('./bridge/drivers/continue.js');
+    registry.register("driver", m.continueDriverTarget);
+  }
+  if (registry === pluginRegistry) _driversRegistered = true;
+}
+async function createDriver(id, config, ctx) {
+  const target = await resolveDriverTarget(id);
+  return target.create(config, ctx ?? {});
+}
+async function resolveDriverTarget(id) {
+  await registerBuiltinDrivers();
+  const target = pluginRegistry.get("driver", id);
+  if (!target) {
+    if (id in BUILTIN_DRIVER_CATALOG) {
+      throw new Error(`Agent driver "${id}" is not bundled in this build.`);
+    }
+    throw new Error(
+      `Unknown agent driver: "${id}". Available: ${listDrivers().map((d) => d.id).join(", ")}`
+    );
+  }
+  return target;
+}
+function listDrivers() {
+  const merged = /* @__PURE__ */ new Map();
+  for (const info of Object.values(BUILTIN_DRIVER_CATALOG)) {
+    merged.set(info.id, info);
+  }
+  for (const meta of pluginRegistry.list("driver")) {
+    if (!merged.has(meta.id)) {
+      const target = pluginRegistry.get("driver", meta.id);
+      merged.set(meta.id, {
+        id: meta.id,
+        name: meta.displayName,
+        modelAgnostic: target?.modelAgnostic ?? false,
+        supportsInBandAbort: target?.supportsInBandAbort ?? false,
+        // Left absent when the target declares nothing: "speaks no surface" and
+        // "did not say" are different claims, and the platform resolver must be
+        // able to tell them apart before it filters a driver out.
+        ...target?.surfaces ? { surfaces: target.surfaces } : {},
+        ...target?.providerPlurality ? { providerPlurality: target.providerPlurality } : {}
+      });
+    }
+  }
+  return [...merged.values()];
+}
+async function listModelsForDriver(driverId, registry, options) {
+  const target = await resolveDriverTarget(driverId);
+  return await target.listModels?.(registry, options) ?? [];
+}
+
+export { AI_PROVIDER_PRESETS, AgentDriver, BUILTIN_DRIVER_CATALOG, DRIVER_CATALOG, PROVIDER_CREDENTIAL_ENV_PREFIX, PROVIDER_CREDENTIAL_ENV_SUFFIX, buildCredentialHeaders, catalogLayer, conventionalCredentialEnvName, createDriver, deriveRegistryFromLegacyApiKeys, entryCredentialEnv, entryCredentialValue, expandPreset, getBridgeLogger, getProviderPreset, listDrivers, listModelsForDriver, listProviderPresets, presetBaseUrl, probeProviderEntry, providerCredentialEnvName, registerBuiltinDrivers, registryCredentialEnv, registryDriverConfig, resolveEntryCredential, resolvePresetBaseUrl, resolveProbeUrl, toMergedRegistry };
+//# sourceMappingURL=chunk-SG4D2UOK.js.map
+//# sourceMappingURL=chunk-SG4D2UOK.js.map