@kynver-app/runtime 0.2.23 → 0.2.24

package/dist/orchestration-providers/inventory.d.ts

@@ -2,19 +2,42 @@ import { type CodexOrchestrationPath } from "./codex-orchestration-adapter.js";
 import { type HermesCliAdapterStatus } from "./hermes-cli-adapter.js";
 import { type HermesOpenAiCodexBindingStatus } from "./hermes-openai-codex-binding.js";
 import type { OrchestrationProviderBindingStatus, OrchestrationProviderId } from "./types.js";
+/**
+ * PRESENCE-ONLY report of cloud API keys on the daemon host env.
+ *
+ * Honesty note (model-freedom audit gap 8): these keys are NOT usable by
+ * harness CLI workers — the worker-env scrub (`worker-env.ts`) strips every
+ * `*_API_KEY` from worker child environments by design. Presence here means
+ * only "the key exists on the daemon host" (e.g. for daemon-side HTTP paths);
+ * it must never be advertised as spendable worker credit.
+ */
 export interface OrchestrationCloudApiCredits {
-    /** ANTHROPIC_API_KEY configured on host (cloud billing — not BYO OAuth). */
+    /** ANTHROPIC_API_KEY present on the daemon host env (scrubbed from worker children). */
     anthropicApiKey: boolean;
-    /** OPENAI_API_KEY configured on host (cloud billing — distinct from Codex OAuth). */
+    /** OPENAI_API_KEY present on the daemon host env (scrubbed from worker children). */
     openaiApiKey: boolean;
-    /** CODEX_API_KEY configured on host (OpenAI Codex cloud path). */
+    /** CODEX_API_KEY present on the daemon host env (scrubbed from worker children). */
     codexApiKey: boolean;
 }
+/**
+ * W2a — generic `openai-compatible` worker provider endpoint presence.
+ * Unlike the cloud API keys above, this path IS worker-usable: the daemon
+ * builds the request (headers include the key) and hands it to its own runner
+ * child over stdin, so the scrub never blocks it.
+ */
+export interface OrchestrationWorkerEndpoint {
+    /** KYNVER_WORKER_BASE_URL present — the generic provider is endpoint-configured. */
+    baseUrlConfigured: boolean;
+    /** KYNVER_WORKER_API_KEY present (optional — many local servers need none). */
+    apiKeyConfigured: boolean;
+}
 export interface OrchestrationProviderInventory {
     generatedAt: string;
     bindings: Record<OrchestrationProviderId, OrchestrationProviderBindingStatus>;
-    /** API-key cloud paths — separate from local OAuth CLI sessions. */
+    /** API-key PRESENCE on the daemon host — not worker-usable credit (see type doc). */
     cloudApiCredits: OrchestrationCloudApiCredits;
+    /** Generic openai-compatible worker endpoint presence (optional for snapshots from older runtimes). */
+    workerEndpoint?: OrchestrationWorkerEndpoint;
     hermes: HermesCliAdapterStatus;
     hermesOpenAiCodex: HermesOpenAiCodexBindingStatus;
     codexAdapterPath: CodexOrchestrationPath;

package/dist/providers/model-preflight.d.ts

@@ -30,4 +30,12 @@ export declare function preflightClaudeModel(model: string | undefined, defaultM
  */
 /** Preflight for `codex` provider — accepts OpenAI/Codex model ids; rejects Claude-family ids. */
 export declare function preflightCodexModel(model: string | undefined, defaultModel: string): ModelPreflightResult;
+/**
+ * Preflight for the generic `openai-compatible` provider. The endpoint behind
+ * `KYNVER_WORKER_BASE_URL` is the only judge of model validity — llama, qwen,
+ * mistral, deepseek, gpt-* and anything else all pass. The ONLY structural
+ * failure is having no model at all (no request and no provider default): a
+ * chat-completions call cannot be issued without one.
+ */
+export declare function preflightOpenAiCompatibleModel(model: string | undefined, defaultModel: string | undefined): ModelPreflightResult;
 export declare function preflightCursorModel(model: string | undefined, defaultModel: string): ModelPreflightResult;

package/dist/providers/openai-compatible-response.d.ts

@@ -0,0 +1,23 @@
+export interface OpenAiCompatibleUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+}
+export interface OpenAiCompatibleCompletion {
+    ok: true;
+    /** Assistant message text (choices[0].message.content, string-joined). */
+    content: string;
+    /** Model id the endpoint reports serving (may differ from the requested id). */
+    model?: string;
+    /** usage.prompt_tokens / usage.completion_tokens when the endpoint reports them. */
+    usage?: OpenAiCompatibleUsage;
+}
+export interface OpenAiCompatibleCompletionError {
+    ok: false;
+    error: string;
+}
+/**
+ * Extract the assistant output + usage from a chat-completions response body.
+ * Tolerant of the shape variance across Ollama/vLLM/OpenRouter/Together/OpenAI —
+ * the caller only needs `content` (the work product) and optional usage/model.
+ */
+export declare function extractOpenAiCompatibleCompletion(body: unknown): OpenAiCompatibleCompletion | OpenAiCompatibleCompletionError;

package/dist/providers/openai-compatible-runner.d.ts

@@ -0,0 +1 @@
+export declare function runOpenAiCompatibleWorkUnit(): Promise<void>;

package/dist/providers/openai-compatible.d.ts

@@ -0,0 +1,46 @@
+import type { WorkerProvider, WorkerProviderStartOptions } from "./types.js";
+export declare const OPENAI_COMPATIBLE_PROVIDER = "openai-compatible";
+export declare function resolveOpenAiCompatibleDefaultModel(env?: NodeJS.ProcessEnv): string | undefined;
+export interface OpenAiCompatibleEndpoint {
+    /** Normalized base URL without a trailing slash, e.g. http://localhost:11434/v1 */
+    baseUrl: string;
+    /** Raw API key when configured; never placed in a child env. */
+    apiKey?: string;
+    timeoutMs: number;
+}
+export declare class OpenAiCompatibleConfigError extends Error {
+}
+/**
+ * Resolve the endpoint from the DAEMON host env. Throws a remediation-quality
+ * error when `KYNVER_WORKER_BASE_URL` is unset or not an http(s) URL.
+ */
+export declare function resolveOpenAiCompatibleEndpoint(env?: NodeJS.ProcessEnv): OpenAiCompatibleEndpoint;
+export declare const OPENAI_COMPATIBLE_SYSTEM_PROMPT: string;
+export interface OpenAiCompatibleChatRequest {
+    url: string;
+    /** Fully constructed headers — the Authorization bearer is baked in here. */
+    headers: Record<string, string>;
+    body: {
+        model: string;
+        temperature: number;
+        stream: false;
+        messages: Array<{
+            role: "system" | "user";
+            content: string;
+        }>;
+    };
+}
+/** Build the single chat-completions request for a work unit. Pure — testable. */
+export declare function buildOpenAiCompatibleChatRequest(endpoint: Pick<OpenAiCompatibleEndpoint, "baseUrl" | "apiKey">, model: string, prompt: string): OpenAiCompatibleChatRequest;
+/** Config the runner child receives over STDIN (never argv/env/disk — carries the key). */
+export interface OpenAiCompatibleRunnerConfig {
+    provider: typeof OPENAI_COMPATIBLE_PROVIDER;
+    model: string;
+    request: OpenAiCompatibleChatRequest;
+    timeoutMs: number;
+    heartbeatPath: string;
+    /** Redacted origin for log/error messages (no path, no credentials). */
+    endpointOrigin: string;
+}
+export declare function buildOpenAiCompatibleRunnerConfig(opts: Pick<WorkerProviderStartOptions, "prompt" | "heartbeatPath">, endpoint: OpenAiCompatibleEndpoint, model: string): OpenAiCompatibleRunnerConfig;
+export declare const openAiCompatibleProvider: WorkerProvider;