@imricci/zaker 0.1.1 → 0.1.3

package/dist/infra/config.js

@@ -13,11 +13,13 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const openai_1 = __importDefault(require("openai"));
 const zod_1 = require("zod");
+const alignment_reply_1 = require("../core/alignment-reply");
 const auditor_1 = require("../core/auditor");
 const planner_1 = require("../core/planner");
 const memory_1 = require("./memory");
 const types_1 = require("../core/types");
 const intent_1 = require("./intent");
+const provider_registry_1 = require("./provider-registry");
 exports.CONFIG_SCHEMA_VERSION = "zaker.config.v1";
 const DEFAULT_RISK_PATH_FILE = ".zaker/risk_paths.yaml";
 const DEFAULT_RISK_PATHS = "risk_paths: []\n";
@@ -29,13 +31,29 @@ const configSchema = zod_1.z.object({
         forbidden_paths: zod_1.z.array(zod_1.z.string().min(1)).default([])
     }),
     model: zod_1.z.object({
-        provider: zod_1.z.enum(["mock", "http", "openai_codex_team"]).default("mock"),
+        provider: zod_1.z.string().min(1).default("mock"),
+        auth_mode: zod_1.z.enum(["api_key", "oauth"]).default("api_key"),
         endpoint: zod_1.z.string().optional(),
         api_key_env: zod_1.z.string().optional(),
         api_key: zod_1.z.string().optional(),
         models_path: zod_1.z.string().optional(),
-        planner_model: zod_1.z.string().min(1).default("qwen3-coder-30b"),
-        auditor_model: zod_1.z.string().min(1).default("kimi-k2.5"),
+        selection_policy: zod_1.z
+            .enum(["strict", "provider_default", "first_available"])
+            .default("provider_default"),
+        fallback_model: zod_1.z.string().default(""),
+        planner_model: zod_1.z.string().min(1).default("auto"),
+        auditor_model: zod_1.z.string().min(1).default("auto"),
+        accounts: zod_1.z
+            .record(zod_1.z.object({
+            auth_mode: zod_1.z.enum(["api_key", "oauth"]).optional(),
+            endpoint: zod_1.z.string().optional(),
+            api_key_env: zod_1.z.string().optional(),
+            api_key: zod_1.z.string().optional(),
+            default_model: zod_1.z.string().optional(),
+            models: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+            updated_at: zod_1.z.string().optional()
+        }))
+            .default({}),
         timeout_ms: zod_1.z.number().int().positive().optional()
     }),
     risk: zod_1.z.object({
@@ -51,13 +69,13 @@ const configSchema = zod_1.z.object({
     execution: zod_1.z
         .object({
         provider: zod_1.z.enum(["local", "cheap_cloud", "ollama"]).default("local"),
-        model: zod_1.z.string().min(1).default("qwen3-coder-30b"),
+        model: zod_1.z.string().min(1).default("auto"),
         ollama_host: zod_1.z.string().min(1).default("http://127.0.0.1:11434"),
         max_attempts: zod_1.z.number().int().min(1).max(5).default(2)
     })
         .default({
         provider: "local",
-        model: "qwen3-coder-30b",
+        model: "auto",
         ollama_host: "http://127.0.0.1:11434",
         max_attempts: 2
     })
@@ -70,12 +88,16 @@ const DEFAULT_CONFIG = {
     },
     model: {
         provider: "mock",
+        auth_mode: "api_key",
         endpoint: "",
         api_key_env: "ZAKER_API_KEY",
         api_key: "",
         models_path: "/models",
-        planner_model: "qwen3-coder-30b",
-        auditor_model: "kimi-k2.5",
+        selection_policy: "provider_default",
+        fallback_model: "",
+        planner_model: "auto",
+        auditor_model: "auto",
+        accounts: {},
         timeout_ms: 30000
     },
     risk: {
@@ -87,11 +109,70 @@ const DEFAULT_CONFIG = {
     },
     execution: {
         provider: "local",
-        model: "qwen3-coder-30b",
+        model: "auto",
         ollama_host: "http://127.0.0.1:11434",
         max_attempts: 2
     }
 };
+function normalizeProviderConfig(config) {
+    const provider = (0, provider_registry_1.toCanonicalModelProviderId)(config.model.provider);
+    const authMode = config.model.auth_mode || "api_key";
+    const apiKeyEnv = config.model.api_key_env?.trim() || (0, provider_registry_1.resolveProviderApiKeyEnv)(provider, authMode);
+    const selectionPolicy = config.model.selection_policy || "provider_default";
+    const fallbackModel = config.model.fallback_model?.trim() || "";
+    const plannerModel = config.model.planner_model?.trim() || "auto";
+    const auditorModel = config.model.auditor_model?.trim() || "auto";
+    const endpoint = config.model.endpoint?.trim() || "";
+    const accounts = {};
+    for (const [rawProviderId, rawAccount] of Object.entries(config.model.accounts || {})) {
+        let accountProvider;
+        try {
+            accountProvider = (0, provider_registry_1.toCanonicalModelProviderId)(rawProviderId);
+        }
+        catch {
+            continue;
+        }
+        const accountAuthMode = rawAccount.auth_mode || "api_key";
+        const accountApiKeyEnv = rawAccount.api_key_env?.trim() || (0, provider_registry_1.resolveProviderApiKeyEnv)(accountProvider, accountAuthMode);
+        accounts[accountProvider] = {
+            auth_mode: accountAuthMode,
+            endpoint: rawAccount.endpoint?.trim() || "",
+            api_key_env: accountApiKeyEnv,
+            api_key: rawAccount.api_key?.trim() || "",
+            default_model: rawAccount.default_model?.trim() || "",
+            models: [...new Set((rawAccount.models || []).map((item) => item.trim()).filter(Boolean))],
+            updated_at: rawAccount.updated_at
+        };
+    }
+    if (provider !== "mock") {
+        const existing = accounts[provider];
+        accounts[provider] = {
+            ...existing,
+            auth_mode: authMode,
+            endpoint: endpoint || existing?.endpoint || "",
+            api_key_env: apiKeyEnv,
+            api_key: config.model.api_key?.trim() || existing?.api_key || "",
+            default_model: config.model.fallback_model?.trim() || existing?.default_model || "",
+            models: [...new Set((existing?.models || []).map((item) => item.trim()).filter(Boolean))],
+            updated_at: existing?.updated_at
+        };
+    }
+    return {
+        ...config,
+        model: {
+            ...config.model,
+            provider,
+            auth_mode: authMode,
+            api_key_env: apiKeyEnv,
+            selection_policy: selectionPolicy,
+            fallback_model: fallbackModel,
+            planner_model: plannerModel,
+            auditor_model: auditorModel,
+            endpoint,
+            accounts
+        }
+    };
+}
 function cloneDefaultConfig() {
     return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
 }
@@ -118,7 +199,7 @@ async function writeConfig(configPath, config) {
     await (0, promises_1.writeFile)(configPath, formatJson(config), "utf8");
 }
 async function writeZakerConfig(config, cwd = process.cwd()) {
-    const normalized = configSchema.parse(config);
+    const normalized = normalizeProviderConfig(configSchema.parse(config));
     const zakerDir = (0, node_path_1.resolve)(cwd, ".zaker");
     const configPath = (0, node_path_1.resolve)(zakerDir, "config.json");
     await (0, promises_1.mkdir)(zakerDir, { recursive: true });
@@ -186,7 +267,7 @@ async function readConfig(cwd = process.cwd()) {
         throw new Error("Missing .zaker/config.json. Run `zaker init` first.");
     }
     const raw = await (0, promises_1.readFile)(configPath, "utf8");
-    return configSchema.parse(JSON.parse(raw));
+    return normalizeProviderConfig(configSchema.parse(JSON.parse(raw)));
 }
 class MockLLMProvider {
     async plan(prompt) {
@@ -209,6 +290,16 @@ class MockLLMProvider {
             message: "Mock provider accepted checkpoint."
         };
     }
+    async align(message) {
+        return (0, alignment_reply_1.generateAlignmentReply)(message);
+    }
+    async detectBuildIntent() {
+        return {
+            ready: false,
+            confidence: 0,
+            signal: "mock_provider"
+        };
+    }
 }
 function resolveApiToken(apiKey, apiKeyEnv, fallbackEnv) {
     const explicit = apiKey.trim();
@@ -230,7 +321,7 @@ function resolveApiToken(apiKey, apiKeyEnv, fallbackEnv) {
 function parseJsonPayload(text, context) {
     const trimmed = text.trim();
     if (!trimmed) {
-        throw new Error(`OpenAI provider returned empty ${context} payload.`);
+        throw new Error(`Provider returned empty ${context} payload.`);
     }
     const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
     const candidate = fenced ? fenced[1].trim() : trimmed;
@@ -248,20 +339,106 @@ function parseJsonPayload(text, context) {
             // try next candidate
         }
     }
-    throw new Error(`OpenAI provider returned non-JSON ${context} payload.`);
+    throw new Error(`Provider returned non-JSON ${context} payload.`);
+}
+function normalizeBuildIntentSignal(raw) {
+    const clampConfidence = (value) => {
+        if (!Number.isFinite(value)) {
+            return 0;
+        }
+        return Math.max(0, Math.min(1, value));
+    };
+    const coerceBoolean = (value) => {
+        if (typeof value === "boolean") {
+            return value;
+        }
+        if (typeof value !== "string") {
+            return null;
+        }
+        const normalized = value.trim().toLowerCase();
+        if (["true", "yes", "y", "ready", "build"].includes(normalized)) {
+            return true;
+        }
+        if (["false", "no", "n", "not_ready", "wait"].includes(normalized)) {
+            return false;
+        }
+        return null;
+    };
+    const extract = (input) => {
+        const readyValue = coerceBoolean(input.ready) ??
+            coerceBoolean(input.ready_to_build) ??
+            coerceBoolean(input.should_build) ??
+            coerceBoolean(input.execute_now) ??
+            false;
+        const confidenceSource = input.confidence;
+        const confidence = typeof confidenceSource === "number"
+            ? clampConfidence(confidenceSource)
+            : readyValue
+                ? 0.7
+                : 0;
+        const signalSource = input.signal ?? input.reason ?? input.label;
+        const signal = typeof signalSource === "string" && signalSource.trim()
+            ? signalSource.trim().toLowerCase()
+            : readyValue
+                ? "ready"
+                : "not_ready";
+        return { ready: readyValue, confidence, signal };
+    };
+    if (raw && typeof raw === "object") {
+        return extract(raw);
+    }
+    if (typeof raw === "string") {
+        const text = raw.trim();
+        if (!text) {
+            return { ready: false, confidence: 0, signal: "empty" };
+        }
+        try {
+            const parsed = parseJsonPayload(text, "build intent signal");
+            if (parsed && typeof parsed === "object") {
+                return extract(parsed);
+            }
+        }
+        catch {
+            // fall through to text heuristic
+        }
+        const lowered = text.toLowerCase();
+        const ready = /(^|\b)(ready|build|start now|go ahead|execute now)(\b|$)/i.test(lowered);
+        return {
+            ready,
+            confidence: ready ? 0.65 : 0.2,
+            signal: ready ? "ready_text" : "not_ready_text"
+        };
+    }
+    return { ready: false, confidence: 0, signal: "invalid" };
+}
+function createAbortError(message) {
+    const error = new Error(message);
+    error.name = "AbortError";
+    return error;
+}
+function isAbortLikeError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    if (error.name === "AbortError") {
+        return true;
+    }
+    return /abort|cancel/i.test(error.message);
 }
-class OpenAICodexTeamProvider {
+class OpenAICompatibleProvider {
+    provider;
     plannerModel;
     auditorModel;
     timeoutMs;
     client;
-    constructor(plannerModel, auditorModel, apiKeyEnv = "OPENAI_API_KEY", apiKey = "", timeoutMs = 30000, endpoint) {
+    constructor(provider, plannerModel, auditorModel, apiKeyEnv = "OPENAI_API_KEY", apiKey = "", timeoutMs = 30000, endpoint) {
+        this.provider = provider;
         this.plannerModel = plannerModel;
         this.auditorModel = auditorModel;
         this.timeoutMs = timeoutMs;
         const token = resolveApiToken(apiKey, apiKeyEnv, "OPENAI_API_KEY");
         if (!token) {
-            throw new Error(`OpenAI provider selected but API key missing. Set model.api_key or env ${apiKeyEnv}.`);
+            throw new Error(`Provider "${this.provider}" selected but credential missing. Set model.api_key or env ${apiKeyEnv}.`);
         }
         this.client = new openai_1.default({
             apiKey: token,
@@ -287,7 +464,7 @@ class OpenAICodexTeamProvider {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`OpenAI provider request failed: ${message}`);
+            throw new Error(`Provider "${this.provider}" request failed: ${message}`);
         }
     }
     async plan(prompt) {
@@ -314,6 +491,278 @@ class OpenAICodexTeamProvider {
         }
         return (0, auditor_1.normalizeAuditResult)(raw);
     }
+    async align(message, context) {
+        if (context?.abort_signal?.aborted) {
+            throw createAbortError(`Provider "${this.provider}" align request cancelled.`);
+        }
+        const contextText = context?.intent_update?.trim();
+        const userPrompt = contextText
+            ? `user_message: ${message}\nintent_update: ${contextText}`
+            : `user_message: ${message}`;
+        try {
+            const completion = await this.client.chat.completions.create({
+                model: this.plannerModel,
+                messages: [
+                    {
+                        role: "system",
+                        content: [
+                            "You are zaker alignment assistant.",
+                            "Reply in concise Chinese.",
+                            "Focus on requirement clarification and next actionable step.",
+                            "Do not claim execution/test success."
+                        ].join(" ")
+                    },
+                    { role: "user", content: userPrompt }
+                ]
+            }, context?.abort_signal
+                ? {
+                    signal: context.abort_signal
+                }
+                : undefined);
+            const text = completion.choices[0]?.message?.content;
+            if (typeof text !== "string" || !text.trim()) {
+                throw new Error("missing alignment response content");
+            }
+            return text.trim();
+        }
+        catch (error) {
+            if (isAbortLikeError(error)) {
+                throw createAbortError(`Provider "${this.provider}" align request cancelled.`);
+            }
+            const messageText = error instanceof Error ? error.message : String(error);
+            throw new Error(`Provider "${this.provider}" align request failed: ${messageText}`);
+        }
+    }
+    async detectBuildIntent(message, context) {
+        if (context?.abort_signal?.aborted) {
+            throw createAbortError(`Provider "${this.provider}" build intent request cancelled.`);
+        }
+        const contextText = context?.intent_update?.trim();
+        const userPrompt = contextText
+            ? `user_message: ${message}\nintent_update: ${contextText}`
+            : `user_message: ${message}`;
+        try {
+            const raw = await this.requestJson(this.plannerModel, [
+                "You are zaker build-intent classifier.",
+                "Return JSON only with keys: ready(boolean), confidence(number 0-1), signal(string).",
+                "Set ready=true only when user is explicitly asking to start implementation now.",
+                "If user is still exploring or unclear, set ready=false."
+            ].join(" "), userPrompt);
+            return normalizeBuildIntentSignal(raw);
+        }
+        catch (error) {
+            if (isAbortLikeError(error)) {
+                throw createAbortError(`Provider "${this.provider}" build intent request cancelled.`);
+            }
+            const messageText = error instanceof Error ? error.message : String(error);
+            throw new Error(`Provider "${this.provider}" build intent request failed: ${messageText}`);
+        }
+    }
+}
+function toPiAiProviderId(provider) {
+    if (provider === "mock" || provider === "http") {
+        throw new Error(`Provider "${provider}" cannot be mapped to pi-ai runtime.`);
+    }
+    return provider;
+}
+async function loadPiAiModule() {
+    const dynamicImport = new Function("specifier", "return import(specifier);");
+    const loaded = await dynamicImport("@mariozechner/pi-ai");
+    return loaded;
+}
+function applyModelEndpointOverride(model, endpoint) {
+    const normalizedEndpoint = endpoint?.trim();
+    if (!normalizedEndpoint || normalizedEndpoint === model.baseUrl) {
+        return model;
+    }
+    const normalizedApi = model.api === "openai-responses" || model.api === "openai-codex-responses"
+        ? "openai-completions"
+        : model.api;
+    return {
+        ...model,
+        api: normalizedApi,
+        baseUrl: normalizedEndpoint
+    };
+}
+function extractPiAiText(message) {
+    return message.content
+        .filter((item) => item.type === "text" && typeof item.text === "string")
+        .map((item) => item.text?.trim() || "")
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+}
+class PiAiProvider {
+    provider;
+    plannerModel;
+    auditorModel;
+    timeoutMs;
+    endpoint;
+    modulePromise;
+    providerId;
+    token;
+    constructor(provider, runtimeProviderId, plannerModel, auditorModel, apiKeyEnv = "OPENAI_API_KEY", apiKey = "", timeoutMs = 30000, endpoint) {
+        this.provider = provider;
+        this.plannerModel = plannerModel;
+        this.auditorModel = auditorModel;
+        this.timeoutMs = timeoutMs;
+        this.endpoint = endpoint;
+        this.providerId = runtimeProviderId?.trim() || toPiAiProviderId(provider);
+        const token = resolveApiToken(apiKey, apiKeyEnv, "OPENAI_API_KEY");
+        if (!token) {
+            throw new Error(`Provider "${this.provider}" selected but credential missing. Set model.api_key or env ${apiKeyEnv}.`);
+        }
+        this.token = token;
+        this.modulePromise = loadPiAiModule();
+    }
+    async resolveModel(requestedModel) {
+        const piAi = await this.modulePromise;
+        const models = piAi.getModels(this.providerId);
+        if (!Array.isArray(models) || models.length === 0) {
+            throw new Error(`Provider "${this.provider}" has no available models in pi-ai catalog.`);
+        }
+        const requested = requestedModel.trim();
+        const providerDefault = (0, provider_registry_1.resolveProviderDefaultModel)(this.provider).trim();
+        const targetModel = requested && requested !== "auto" ? requested : providerDefault;
+        let resolved = targetModel ? models.find((item) => item.id === targetModel) : undefined;
+        if (!resolved && requested && requested !== "auto") {
+            const endpointOverride = this.endpoint?.trim();
+            if (endpointOverride) {
+                const prototype = models[0];
+                if (!prototype) {
+                    throw new Error(`Provider "${this.provider}" has no model prototype for endpoint override.`);
+                }
+                return applyModelEndpointOverride({
+                    ...prototype,
+                    id: requested,
+                    name: requested
+                }, endpointOverride);
+            }
+            const sample = models.slice(0, 8).map((item) => item.id).join(", ");
+            throw new Error(`Provider "${this.provider}" model "${requested}" not found in pi-ai catalog. Sample: ${sample}`);
+        }
+        if (!resolved) {
+            resolved = models[0];
+        }
+        if (!resolved) {
+            throw new Error(`Provider "${this.provider}" has no resolvable model in pi-ai catalog.`);
+        }
+        return applyModelEndpointOverride(resolved, this.endpoint);
+    }
+    async completeText(modelId, systemPrompt, userPrompt, abortSignal) {
+        if (abortSignal?.aborted) {
+            throw createAbortError(`Provider "${this.provider}" request cancelled.`);
+        }
+        const piAi = await this.modulePromise;
+        const model = await this.resolveModel(modelId);
+        const controller = new AbortController();
+        let abortedByExternal = false;
+        let timedOut = false;
+        const onExternalAbort = () => {
+            abortedByExternal = true;
+            controller.abort();
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, this.timeoutMs);
+        if (abortSignal) {
+            abortSignal.addEventListener("abort", onExternalAbort, { once: true });
+        }
+        try {
+            const message = await piAi.complete(model, {
+                systemPrompt,
+                messages: [
+                    {
+                        role: "user",
+                        content: userPrompt,
+                        timestamp: Date.now()
+                    }
+                ]
+            }, {
+                apiKey: this.token,
+                signal: controller.signal
+            });
+            if (message.stopReason === "error") {
+                throw new Error(message.errorMessage || "pi-ai returned stopReason=error");
+            }
+            const text = extractPiAiText(message);
+            if (!text) {
+                throw new Error(`missing response text: ${JSON.stringify(message)}`);
+            }
+            return text;
+        }
+        catch (error) {
+            if (isAbortLikeError(error)) {
+                if (abortedByExternal || abortSignal?.aborted) {
+                    throw createAbortError(`Provider "${this.provider}" request cancelled.`);
+                }
+                if (timedOut) {
+                    throw new Error(`Provider "${this.provider}" request timeout after ${this.timeoutMs}ms.`);
+                }
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Provider "${this.provider}" request failed: ${message}`);
+        }
+        finally {
+            clearTimeout(timer);
+            if (abortSignal) {
+                abortSignal.removeEventListener("abort", onExternalAbort);
+            }
+        }
+    }
+    async plan(prompt) {
+        const text = await this.completeText(this.plannerModel, [
+            "You are ZAKER planner.",
+            "Return JSON only.",
+            "Output must follow zaker.sop.v1 with fields:",
+            "schema_version,sop_id,goal,scope,verification,limits,skills,tasks,patches."
+        ].join(" "), prompt);
+        const raw = parseJsonPayload(text, "plan");
+        if (raw && typeof raw === "object" && "sop" in raw) {
+            return (0, planner_1.validateSOP)(raw.sop, prompt);
+        }
+        return (0, planner_1.validateSOP)(raw, prompt);
+    }
+    async audit(checkpoint) {
+        const text = await this.completeText(this.auditorModel, [
+            "You are ZAKER auditor.",
+            "Return JSON only.",
+            "Output must follow zaker.audit.v1 with fields:",
+            "schema_version,verdict,reason_code,message,challenge(optional)."
+        ].join(" "), JSON.stringify({ checkpoint }, null, 2));
+        const raw = parseJsonPayload(text, "audit");
+        if (raw && typeof raw === "object" && "audit" in raw) {
+            return (0, auditor_1.normalizeAuditResult)(raw.audit);
+        }
+        return (0, auditor_1.normalizeAuditResult)(raw);
+    }
+    async align(message, context) {
+        const contextText = context?.intent_update?.trim();
+        const userPrompt = contextText
+            ? `user_message: ${message}\nintent_update: ${contextText}`
+            : `user_message: ${message}`;
+        return await this.completeText(this.plannerModel, [
+            "You are zaker alignment assistant.",
+            "Reply in concise Chinese.",
+            "Focus on requirement clarification and next actionable step.",
+            "Do not claim execution/test success."
+        ].join(" "), userPrompt, context?.abort_signal);
+    }
+    async detectBuildIntent(message, context) {
+        const contextText = context?.intent_update?.trim();
+        const userPrompt = contextText
+            ? `user_message: ${message}\nintent_update: ${contextText}`
+            : `user_message: ${message}`;
+        const text = await this.completeText(this.plannerModel, [
+            "You are zaker build-intent classifier.",
+            "Return JSON only with keys: ready(boolean), confidence(number 0-1), signal(string).",
+            "Set ready=true only when user explicitly indicates starting implementation now.",
+            "If unsure, set ready=false."
+        ].join(" "), userPrompt, context?.abort_signal);
+        const raw = parseJsonPayload(text, "build intent signal");
+        return normalizeBuildIntentSignal(raw);
+    }
 }
 class HttpLLMProvider {
     endpoint;
@@ -330,8 +779,19 @@ class HttpLLMProvider {
         this.apiKey = apiKey;
         this.timeoutMs = timeoutMs;
     }
-    async post(path, payload) {
+    async post(path, payload, abortSignal) {
+        if (abortSignal?.aborted) {
+            throw createAbortError(`LLM provider request cancelled: POST ${path}`);
+        }
         const controller = new AbortController();
+        let abortedByExternal = false;
+        const onExternalAbort = () => {
+            abortedByExternal = true;
+            controller.abort();
+        };
+        if (abortSignal) {
+            abortSignal.addEventListener("abort", onExternalAbort, { once: true });
+        }
         const timer = setTimeout(() => controller.abort(), this.timeoutMs);
         try {
             const url = `${this.endpoint.replace(/\/+$/, "")}${path}`;
@@ -354,7 +814,10 @@ class HttpLLMProvider {
             return await response.json();
         }
         catch (error) {
-            if (error instanceof Error && error.name === "AbortError") {
+            if (isAbortLikeError(error)) {
+                if (abortedByExternal || abortSignal?.aborted) {
+                    throw createAbortError(`LLM provider request cancelled: POST ${path}`);
+                }
                 throw new Error(`LLM provider timeout after ${this.timeoutMs}ms: POST ${path}`);
             }
             if (error instanceof Error) {
@@ -364,6 +827,9 @@ class HttpLLMProvider {
         }
         finally {
             clearTimeout(timer);
+            if (abortSignal) {
+                abortSignal.removeEventListener("abort", onExternalAbort);
+            }
         }
     }
     async plan(prompt) {
@@ -380,18 +846,72 @@ class HttpLLMProvider {
         }
         return (0, auditor_1.normalizeAuditResult)(raw);
     }
+    async align(message, context) {
+        const raw = await this.post("/align", {
+            message,
+            model: this.plannerModel,
+            intent_update: context?.intent_update || ""
+        }, context?.abort_signal);
+        if (typeof raw === "string" && raw.trim()) {
+            return raw.trim();
+        }
+        if (raw && typeof raw === "object") {
+            if ("reply" in raw && typeof raw.reply === "string") {
+                return (raw.reply || "").trim();
+            }
+            if ("message" in raw && typeof raw.message === "string") {
+                return (raw.message || "").trim();
+            }
+        }
+        throw new Error("HTTP provider returned invalid /align payload.");
+    }
+    async detectBuildIntent(message, context) {
+        try {
+            const raw = await this.post("/intent-signal", {
+                message,
+                model: this.plannerModel,
+                intent_update: context?.intent_update || ""
+            }, context?.abort_signal);
+            return normalizeBuildIntentSignal(raw);
+        }
+        catch {
+            const raw = await this.post("/align", {
+                message: [
+                    "Classify whether the user explicitly asks to start implementation now.",
+                    "Return JSON only with keys ready/confidence/signal.",
+                    `user_message: ${message}`,
+                    `intent_update: ${context?.intent_update || ""}`
+                ].join("\n"),
+                model: this.plannerModel,
+                intent_update: context?.intent_update || ""
+            }, context?.abort_signal);
+            return normalizeBuildIntentSignal(raw);
+        }
+    }
 }
 function createLLMProvider(config) {
-    if (config.model.provider === "http") {
+    const provider = (0, provider_registry_1.toCanonicalModelProviderId)(config.model.provider);
+    if (provider === "http") {
         const endpoint = config.model.endpoint?.trim();
         if (!endpoint) {
             throw new Error("HTTP provider selected but model.endpoint is empty.");
         }
         return new HttpLLMProvider(endpoint, config.model.planner_model, config.model.auditor_model, config.model.api_key_env || "ZAKER_API_KEY", config.model.api_key || "", config.model.timeout_ms || 30000);
     }
-    if (config.model.provider === "openai_codex_team") {
-        return new OpenAICodexTeamProvider(config.model.planner_model, config.model.auditor_model, config.model.api_key_env || "OPENAI_API_KEY", config.model.api_key || "", config.model.timeout_ms || 30000, config.model.endpoint);
+    if (provider === "mock") {
+        return new MockLLMProvider();
+    }
+    const authMode = config.model.auth_mode || "api_key";
+    const fallbackEnv = (0, provider_registry_1.resolveProviderApiKeyEnv)(provider, authMode);
+    const providerDefaultEndpoint = (0, provider_registry_1.resolveProviderEndpoint)(provider);
+    const explicitEndpoint = config.model.endpoint?.trim() || "";
+    const hasCustomGatewayEndpoint = explicitEndpoint.length > 0 &&
+        (!providerDefaultEndpoint || explicitEndpoint !== providerDefaultEndpoint);
+    if (hasCustomGatewayEndpoint) {
+        return new OpenAICompatibleProvider(provider, config.model.planner_model, config.model.auditor_model, config.model.api_key_env || fallbackEnv, config.model.api_key || "", config.model.timeout_ms || 30000, explicitEndpoint);
     }
-    return new MockLLMProvider();
+    const runtimeProviderId = provider === "openai-codex" && authMode !== "oauth" ? "openai" : undefined;
+    const endpointOverride = hasCustomGatewayEndpoint ? explicitEndpoint : undefined;
+    return new PiAiProvider(provider, runtimeProviderId, config.model.planner_model, config.model.auditor_model, config.model.api_key_env || fallbackEnv, config.model.api_key || "", config.model.timeout_ms || 30000, endpointOverride);
 }
 //# sourceMappingURL=config.js.map