@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-FCSXB6T2.js

@@ -0,0 +1,338 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  getEngineEnvApiKey
+} from "./chunk-YXLYO42X.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/engine/ai.ts
+init_esm_shims();
+import {
+  fauxAssistantMessage,
+  calculateCost as piCalculateCost,
+  cleanupSessionResources as piCleanupSessionResources,
+  getSupportedThinkingLevels as piGetSupportedThinkingLevels,
+  isContextOverflow as piIsContextOverflow,
+  isRetryableAssistantError as piIsRetryableAssistantError,
+  validateToolArguments as piValidateToolArguments,
+  StringEnum
+} from "@earendil-works/pi-ai";
+
+// src/engine/api-registry.ts
+init_esm_shims();
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { azureOpenAIResponsesApi } from "@earendil-works/pi-ai/api/azure-openai-responses.lazy";
+import { bedrockConverseStreamApi } from "@earendil-works/pi-ai/api/bedrock-converse-stream.lazy";
+import { googleGenerativeAIApi } from "@earendil-works/pi-ai/api/google-generative-ai.lazy";
+import { googleVertexApi } from "@earendil-works/pi-ai/api/google-vertex.lazy";
+import { mistralConversationsApi } from "@earendil-works/pi-ai/api/mistral-conversations.lazy";
+import { openAICodexResponsesApi } from "@earendil-works/pi-ai/api/openai-codex-responses.lazy";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { piMessagesApi } from "@earendil-works/pi-ai/api/pi-messages.lazy";
+import {
+  createFauxCore
+} from "@earendil-works/pi-ai/providers/faux";
+import "@earendil-works/pi-ai/providers/images/register-builtins";
+
+// src/engine/models.ts
+init_esm_shims();
+import { createModels } from "@earendil-works/pi-ai";
+import { amazonBedrockProvider } from "@earendil-works/pi-ai/providers/amazon-bedrock";
+import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";
+import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek";
+import { googleProvider } from "@earendil-works/pi-ai/providers/google";
+import { groqProvider } from "@earendil-works/pi-ai/providers/groq";
+import { mistralProvider } from "@earendil-works/pi-ai/providers/mistral";
+import { openaiProvider } from "@earendil-works/pi-ai/providers/openai";
+import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
+import { openrouterProvider } from "@earendil-works/pi-ai/providers/openrouter";
+var CONFIGURED_PROVIDER_FACTORIES = [
+  amazonBedrockProvider,
+  anthropicProvider,
+  deepseekProvider,
+  googleProvider,
+  groqProvider,
+  mistralProvider,
+  openaiProvider,
+  openaiCodexProvider,
+  openrouterProvider
+];
+var engineModels = createModels();
+for (const factory of CONFIGURED_PROVIDER_FACTORIES) engineModels.setProvider(factory());
+function engineModelProviders() {
+  return engineModels.getProviders().map((provider) => provider.id);
+}
+function engineModelsFor(provider) {
+  return [...engineModels.getModels(provider)];
+}
+function getEngineModel(provider, modelId) {
+  return engineModels.getModel(provider, modelId);
+}
+
+// src/engine/api-registry.ts
+var registry = /* @__PURE__ */ new Map();
+var builtinInstances = /* @__PURE__ */ new Map();
+var compatUniverse;
+var compatUniversePromise;
+var builtinsRegistered = false;
+function wrappedProvider(provider) {
+  const { api } = provider;
+  return {
+    api,
+    stream(model, context, options) {
+      if (model.api !== api) throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+      return provider.stream(model, context, options);
+    },
+    streamSimple(model, context, options) {
+      if (model.api !== api) throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+      return provider.streamSimple(model, context, options);
+    }
+  };
+}
+function registerEngineApiProvider(provider, sourceId) {
+  const wrapped = wrappedProvider(provider);
+  registry.set(provider.api, { provider: wrapped, ...sourceId === void 0 ? {} : { sourceId } });
+  compatUniverse?.registerApiProvider(provider, sourceId);
+}
+function unregisterEngineApiProviders(sourceId) {
+  for (const [api, entry] of registry) {
+    if (entry.sourceId === sourceId) registry.delete(api);
+  }
+  compatUniverse?.unregisterApiProviders(sourceId);
+}
+function getEngineApiProvider(api) {
+  return registry.get(api)?.provider;
+}
+var BUILTIN_APIS = [
+  ["anthropic-messages", anthropicMessagesApi()],
+  ["openai-completions", openAICompletionsApi()],
+  ["openai-responses", openAIResponsesApi()],
+  ["openai-codex-responses", openAICodexResponsesApi()],
+  ["azure-openai-responses", azureOpenAIResponsesApi()],
+  ["google-generative-ai", googleGenerativeAIApi()],
+  ["google-vertex", googleVertexApi()],
+  ["mistral-conversations", mistralConversationsApi()],
+  ["bedrock-converse-stream", bedrockConverseStreamApi()],
+  ["pi-messages", piMessagesApi()]
+];
+function registerEngineBuiltins() {
+  if (builtinsRegistered) return;
+  builtinsRegistered = true;
+  for (const [api, streams] of BUILTIN_APIS) {
+    if (!getEngineApiProvider(api)) registerEngineApiProvider({ api, ...streams });
+    const registered2 = getEngineApiProvider(api);
+    if (registered2) builtinInstances.set(api, registered2);
+  }
+}
+function withEnvApiKey(model, options) {
+  if (typeof options?.apiKey === "string" && options.apiKey.trim().length > 0) return options;
+  const apiKey = getEngineEnvApiKey(model.provider, options?.env);
+  if (!apiKey || apiKey === "<authenticated>") return options;
+  return { ...options, apiKey };
+}
+function builtinProvider(model) {
+  if (getEngineApiProvider(model.api) !== builtinInstances.get(model.api)) return void 0;
+  const provider = engineModels.getProvider(model.provider);
+  return provider?.getModels().some((candidate) => candidate.api === model.api) ? provider : void 0;
+}
+function resolved(api) {
+  const provider = getEngineApiProvider(api);
+  if (!provider) throw new Error(`No API provider registered for api: ${api}`);
+  return provider;
+}
+function hasCloudflareAuth(options) {
+  return typeof options?.apiKey === "string" && options.apiKey.trim().length > 0 || typeof options?.headers?.["cf-aig-authorization"] === "string";
+}
+function engineStream(model, context, options) {
+  registerEngineBuiltins();
+  if (compatUniverse) return compatUniverse.stream(model, context, options);
+  const provider = builtinProvider(model);
+  if (provider) {
+    if (model.provider.startsWith("cloudflare-") && !hasCloudflareAuth(options)) {
+      return engineModels.stream(model, context, options);
+    }
+    return provider.stream(model, context, withEnvApiKey(model, options));
+  }
+  return resolved(model.api).stream(model, context, withEnvApiKey(model, options));
+}
+function engineStreamSimple(model, context, options) {
+  registerEngineBuiltins();
+  if (compatUniverse) return compatUniverse.streamSimple(model, context, options);
+  const provider = builtinProvider(model);
+  if (provider) {
+    if (model.provider.startsWith("cloudflare-") && !hasCloudflareAuth(options)) {
+      return engineModels.streamSimple(model, context, options);
+    }
+    return provider.streamSimple(model, context, withEnvApiKey(model, options));
+  }
+  return resolved(model.api).streamSimple(model, context, withEnvApiKey(model, options));
+}
+async function completeEngineSimple(model, context, options) {
+  return engineStreamSimple(model, context, options).result();
+}
+function registerEngineFauxProvider(options = {}) {
+  registerEngineBuiltins();
+  const core = createFauxCore(options);
+  const sourceId = `faux-provider-${Math.random().toString(36).slice(2, 10)}`;
+  registerEngineApiProvider({ api: core.api, stream: core.stream, streamSimple: core.streamSimple }, sourceId);
+  return {
+    api: core.api,
+    models: core.models,
+    getModel: core.getModel,
+    state: core.state,
+    setResponses: core.setResponses,
+    appendResponses: core.appendResponses,
+    getPendingResponseCount: core.getPendingResponseCount,
+    unregister() {
+      unregisterEngineApiProviders(sourceId);
+    }
+  };
+}
+async function activateExternalPluginApiBridge() {
+  if (compatUniverse) return;
+  compatUniversePromise ??= (async () => {
+    registerEngineBuiltins();
+    const compat = await import("@earendil-works/pi-ai/compat");
+    for (const [api, entry] of registry) {
+      if (entry.provider === builtinInstances.get(api)) continue;
+      compat.registerApiProvider(entry.provider, entry.sourceId);
+    }
+    compatUniverse = compat;
+  })().catch((error) => {
+    compatUniversePromise = void 0;
+    throw error;
+  });
+  await compatUniversePromise;
+}
+registerEngineBuiltins();
+
+// src/engine/ai.ts
+var stream = engineStream;
+async function completeEngineText(input) {
+  const response = await completeEngineSimple(
+    input.model,
+    {
+      systemPrompt: input.systemPrompt,
+      messages: [{ role: "user", content: input.userPrompt, timestamp: Date.now() }]
+    },
+    {
+      maxTokens: input.maxTokens,
+      signal: input.signal,
+      timeoutMs: input.timeoutMs,
+      ...input.thinkingLevel === "off" ? {} : { reasoning: input.thinkingLevel },
+      ...input.apiKey === void 0 ? {} : { apiKey: input.apiKey }
+    }
+  );
+  if (response.stopReason === "error" || response.stopReason === "aborted") {
+    throw new Error(response.errorMessage ?? `model completion ${response.stopReason}`);
+  }
+  return {
+    text: response.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+    inputTokens: response.usage.input,
+    outputTokens: response.usage.output
+  };
+}
+var registered = false;
+function ensurePiAiRegistered() {
+  if (registered) return;
+  registerEngineBuiltins();
+  registered = true;
+}
+function createEngineAi() {
+  ensurePiAiRegistered();
+  return {
+    listProviders: () => engineModelProviders(),
+    listModels: (provider) => engineModelsFor(provider),
+    getModel: (provider, modelId) => {
+      try {
+        return getEngineModel(provider, modelId);
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function emptyUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+}
+function getEngineSupportedThinkingLevels(model) {
+  return piGetSupportedThinkingLevels(model);
+}
+function cleanupEngineSessionResources(sessionId) {
+  piCleanupSessionResources(sessionId);
+}
+function isEngineContextOverflow(errorMessage, contextWindow) {
+  const message = {
+    role: "assistant",
+    content: [],
+    api: "clio",
+    provider: "clio",
+    model: "unknown",
+    usage: emptyUsage(),
+    stopReason: "error",
+    errorMessage,
+    timestamp: Date.now()
+  };
+  return piIsContextOverflow(message, contextWindow);
+}
+function isEngineRetryableAssistantError(errorMessage) {
+  const message = {
+    role: "assistant",
+    content: [],
+    api: "clio",
+    provider: "clio",
+    model: "unknown",
+    usage: emptyUsage(),
+    stopReason: "error",
+    errorMessage,
+    timestamp: Date.now()
+  };
+  return piIsRetryableAssistantError(message);
+}
+function calculateEngineCost(model, usage) {
+  return piCalculateCost(model, usage);
+}
+function registerFauxFromEnv() {
+  if (process.env.CLIO_CODER_WORKER_FAUX !== "1") return null;
+  const modelId = process.env.CLIO_CODER_WORKER_FAUX_MODEL ?? "faux-model";
+  const text = process.env.CLIO_CODER_WORKER_FAUX_TEXT ?? "ok";
+  const stopReason = process.env.CLIO_CODER_WORKER_FAUX_STOP_REASON ?? "stop";
+  const errorMessage = process.env.CLIO_CODER_WORKER_FAUX_ERROR_MESSAGE;
+  const reg = registerEngineFauxProvider({
+    provider: "faux",
+    models: [{ id: modelId }]
+  });
+  const response = { stopReason };
+  if (errorMessage && errorMessage.length > 0) {
+    response.errorMessage = errorMessage;
+  }
+  reg.setResponses([fauxAssistantMessage(text, response)]);
+  return reg.getModel(modelId);
+}
+
+export {
+  registerEngineApiProvider,
+  engineStreamSimple,
+  activateExternalPluginApiBridge,
+  StringEnum,
+  stream,
+  completeEngineText,
+  ensurePiAiRegistered,
+  createEngineAi,
+  getEngineSupportedThinkingLevels,
+  cleanupEngineSessionResources,
+  isEngineContextOverflow,
+  isEngineRetryableAssistantError,
+  calculateEngineCost,
+  registerFauxFromEnv
+};
+//# sourceMappingURL=chunk-FCSXB6T2.js.map

package/dist/chunk-FJ3H4MN5.js

@@ -0,0 +1,48 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  StringEnum
+} from "./chunk-FCSXB6T2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/monitor-surface.ts
+init_esm_shims();
+var monitorToolSurface = {
+  name: ToolNames.Monitor,
+  description: "Inspect known dispatched runs. Parent-model mid-run observation requires detach:true because ordinary dispatch auto-waits. wait observes without collecting. collect is the authoritative terminal batch operation; collect detached runs before final synthesis. receipt exposes stored evidence. Receipt integrity, evidence verification, briefing provenance, and project-context provenance are separate fields.",
+  parameters: typebox_exports.Object({
+    run_id: typebox_exports.Optional(
+      typebox_exports.String({ description: "Run id from dispatch output or monitor list; omit with mode=list." })
+    ),
+    mode: typebox_exports.Optional(
+      StringEnum(["status", "peek", "receipt", "list", "wait", "collect", "tools"], {
+        description: "What to return. Defaults to status when run_id is present and list when it is absent. status, peek, receipt, tools, and wait each observe one run and require a run_id; list takes none. tools answers what a run executed: its tool calls with outcomes, plus per-tool totals from the receipt."
+      })
+    ),
+    batch_id: typebox_exports.Optional(typebox_exports.String({ description: "Detached batch id from dispatch detach:true (mode=collect)." })),
+    run_ids: typebox_exports.Optional(
+      typebox_exports.Array(typebox_exports.String(), {
+        description: "Explicit run ids for mode=collect; a one-element array is also accepted by single-run modes when run_id is absent."
+      })
+    ),
+    timeout_ms: typebox_exports.Optional(
+      typebox_exports.Number({
+        description: "mode=wait: max ms to block (default 60000, capped at 600000); mode=collect never blocks and ignores this value with a notice."
+      })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel"
+};
+
+export {
+  monitorToolSurface
+};
+//# sourceMappingURL=chunk-FJ3H4MN5.js.map

package/dist/chunk-FQ4SKYE4.js

@@ -0,0 +1,29 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/timers.ts
+init_esm_shims();
+var MAX_TIMER_DELAY_MS = 2147483647;
+function clampTimerDelayMs(value) {
+  if (Number.isNaN(value) || value <= 0) return 0;
+  return value >= MAX_TIMER_DELAY_MS ? MAX_TIMER_DELAY_MS : Math.floor(value);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var negativeDurations = 0;
+function rawDurationMs(start, end) {
+  const elapsed = end - start;
+  if (elapsed < 0) negativeDurations += 1;
+  return elapsed;
+}
+
+export {
+  MAX_TIMER_DELAY_MS,
+  clampTimerDelayMs,
+  sleep,
+  rawDurationMs
+};
+//# sourceMappingURL=chunk-FQ4SKYE4.js.map