@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/node_modules/@ktx/context/dist/ingest/wiki-sl-ref-repair.test.js

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from 'vitest';
+import { repairWikiSlRefs } from './wiki-sl-ref-repair.js';
+describe('repairWikiSlRefs', () => {
+    it('removes missing measure refs while keeping source, measure, segment, and manifest-backed refs', async () => {
+        const pages = new Map([
+            [
+                'GLOBAL:accounts-at-risk',
+                {
+                    pageKey: 'accounts-at-risk',
+                    frontmatter: {
+                        summary: 'Accounts at risk',
+                        usage_mode: 'auto',
+                        sl_refs: [
+                            'mart_customer_health',
+                            'mart_customer_health.high_risk_account_count',
+                            'mart_customer_health.medium_risk_account_count',
+                            'mart_customer_health.high_risk',
+                            'int_procurement_qualifying_actions',
+                        ],
+                    },
+                    content: 'Risk context.',
+                },
+            ],
+        ]);
+        const wikiService = {
+            readPage: vi.fn(async (scope, _scopeId, key) => pages.get(`${scope}:${key}`)),
+            writePage: vi.fn(async (scope, _scopeId, key, frontmatter, content) => {
+                pages.set(`${scope}:${key}`, { pageKey: key, frontmatter, content });
+            }),
+        };
+        const configService = {
+            listFiles: vi.fn(async () => ({
+                files: ['global/accounts-at-risk.md', 'global/historic-sql/nested-old.md'],
+            })),
+        };
+        const semanticLayerService = {
+            loadAllSources: vi.fn(async () => ({
+                sources: [
+                    {
+                        name: 'mart_customer_health',
+                        grain: [],
+                        columns: [],
+                        joins: [],
+                        measures: [{ name: 'high_risk_account_count', expr: 'count(*)' }],
+                        segments: [{ name: 'high_risk', expr: "risk_level = 'high'" }],
+                    },
+                    {
+                        name: 'int_procurement_qualifying_actions',
+                        grain: [],
+                        columns: [],
+                        joins: [],
+                        measures: [],
+                    },
+                ],
+                loadErrors: [],
+            })),
+        };
+        const result = await repairWikiSlRefs({
+            wikiService: wikiService,
+            semanticLayerService: semanticLayerService,
+            configService: configService,
+            connectionIds: ['warehouse'],
+        });
+        expect(result.repairs).toEqual([
+            {
+                pageKey: 'accounts-at-risk',
+                scope: 'GLOBAL',
+                scopeId: null,
+                removedRefs: ['mart_customer_health.medium_risk_account_count'],
+            },
+        ]);
+        expect(wikiService.writePage).toHaveBeenCalledWith('GLOBAL', null, 'accounts-at-risk', expect.objectContaining({
+            sl_refs: [
+                'mart_customer_health',
+                'mart_customer_health.high_risk_account_count',
+                'mart_customer_health.high_risk',
+                'int_procurement_qualifying_actions',
+            ],
+        }), 'Risk context.', 'System User', 'system@example.com', 'Repair semantic-layer refs: accounts-at-risk');
+    });
+});

package/node_modules/@ktx/context/dist/llm/ai-sdk-runtime.d.ts

@@ -0,0 +1,23 @@
+import { type KtxLlmProvider } from '@ktx/llm';
+import { type TelemetrySettings } from 'ai';
+import type { z } from 'zod';
+import { type KtxLogger } from '../core/index.js';
+import { type KtxLlmDebugRequestRecorder } from './debug-request-recorder.js';
+import type { KtxGenerateObjectInput, KtxGenerateTextInput, KtxLlmRuntimePort, RunLoopParams, RunLoopResult } from './runtime-port.js';
+export interface AgentTelemetryPort {
+    createTelemetry(tags: Record<string, string>): TelemetrySettings;
+}
+export interface AiSdkKtxLlmRuntimeDeps {
+    llmProvider: KtxLlmProvider;
+    telemetry?: AgentTelemetryPort;
+    logger?: KtxLogger;
+    debugRequestRecorder?: KtxLlmDebugRequestRecorder;
+}
+export declare class AiSdkKtxLlmRuntime implements KtxLlmRuntimePort {
+    private readonly deps;
+    private readonly logger;
+    constructor(deps: AiSdkKtxLlmRuntimeDeps);
+    generateText(input: KtxGenerateTextInput): Promise<string>;
+    generateObject<TOutput, TSchema extends z.ZodType<TOutput>>(input: KtxGenerateObjectInput<TOutput, TSchema>): Promise<TOutput>;
+    runAgentLoop(params: RunLoopParams): Promise<RunLoopResult>;
+}

package/node_modules/@ktx/context/dist/llm/ai-sdk-runtime.js

@@ -0,0 +1,133 @@
+import { KtxMessageBuilder, splitKtxSystemMessages } from '@ktx/llm';
+import { generateText, Output, stepCountIs } from 'ai';
+import { noopLogger } from '../core/index.js';
+import { summarizeKtxLlmDebugRequest } from './debug-request-recorder.js';
+import { createAiSdkToolSet } from './runtime-tools.js';
+function hasTools(tools) {
+    return Object.keys(tools).length > 0;
+}
+export class AiSdkKtxLlmRuntime {
+    deps;
+    logger;
+    constructor(deps) {
+        this.deps = deps;
+        this.logger = deps.logger ?? noopLogger;
+    }
+    async generateText(input) {
+        const model = this.deps.llmProvider.getModel(input.role);
+        if (model.provider === 'deterministic') {
+            return `Deterministic description for ${input.prompt.slice(0, 64).trim() || 'data source'}`;
+        }
+        const tools = createAiSdkToolSet(input.tools ?? {});
+        const built = new KtxMessageBuilder(this.deps.llmProvider).wrapSimple({
+            system: input.system,
+            messages: [{ role: 'user', content: input.prompt }],
+            tools,
+            model,
+        });
+        const split = splitKtxSystemMessages(built.messages);
+        const result = await generateText({
+            model,
+            temperature: input.temperature ?? 0,
+            ...(split.system ? { system: split.system } : {}),
+            messages: split.messages,
+            tools: built.tools,
+            ...(hasTools(tools)
+                ? {
+                    experimental_repairToolCall: this.deps.llmProvider.repairToolCallHandler({
+                        source: `ktx-${input.role}`,
+                    }),
+                }
+                : {}),
+        });
+        if (typeof result.text !== 'string') {
+            throw new Error('KTX LLM text generation returned no text');
+        }
+        return result.text;
+    }
+    async generateObject(input) {
+        const model = this.deps.llmProvider.getModel(input.role);
+        const tools = createAiSdkToolSet(input.tools ?? {});
+        const built = new KtxMessageBuilder(this.deps.llmProvider).wrapSimple({
+            system: input.system,
+            messages: [{ role: 'user', content: input.prompt }],
+            tools,
+            model,
+        });
+        const split = splitKtxSystemMessages(built.messages);
+        const result = await generateText({
+            model,
+            temperature: input.temperature ?? 0,
+            ...(split.system ? { system: split.system } : {}),
+            messages: split.messages,
+            tools: built.tools,
+            ...(hasTools(tools)
+                ? {
+                    experimental_repairToolCall: this.deps.llmProvider.repairToolCallHandler({
+                        source: `ktx-${input.role}`,
+                    }),
+                }
+                : {}),
+            output: Output.object({ schema: input.schema }),
+        });
+        if (result.output == null) {
+            throw new Error('KTX LLM object generation returned no output');
+        }
+        return result.output;
+    }
+    async runAgentLoop(params) {
+        let stepIndex = 0;
+        try {
+            const model = this.deps.llmProvider.getModel(params.modelRole);
+            const tools = createAiSdkToolSet(params.toolSet);
+            const builder = new KtxMessageBuilder(this.deps.llmProvider);
+            const built = builder.wrapSimple({
+                system: params.systemPrompt,
+                messages: [{ role: 'user', content: params.userPrompt }],
+                tools,
+                model,
+            });
+            const promptMessages = splitKtxSystemMessages(built.messages);
+            await this.deps.debugRequestRecorder?.record(summarizeKtxLlmDebugRequest({
+                operationName: params.telemetryTags.operationName ?? 'ktx-agent-runner',
+                source: params.telemetryTags.source,
+                jobId: params.telemetryTags.jobId,
+                unitKey: params.telemetryTags.unitKey,
+                modelRole: params.modelRole,
+                modelId: model.modelId ?? params.modelRole,
+                messages: built.messages,
+                tools: built.tools,
+            }));
+            await generateText({
+                model,
+                temperature: 0,
+                stopWhen: stepCountIs(params.stepBudget),
+                experimental_telemetry: this.deps.telemetry?.createTelemetry(params.telemetryTags) ?? this.deps.llmProvider.telemetryConfig(),
+                experimental_repairToolCall: this.deps.llmProvider.repairToolCallHandler({
+                    source: params.telemetryTags.operationName ?? 'ktx-agent-runner',
+                }),
+                ...(promptMessages.system ? { system: promptMessages.system } : {}),
+                messages: promptMessages.messages,
+                tools: built.tools,
+                onStepFinish: async () => {
+                    stepIndex += 1;
+                    if (!params.onStepFinish) {
+                        return;
+                    }
+                    try {
+                        await params.onStepFinish({ stepIndex, stepBudget: params.stepBudget });
+                    }
+                    catch (err) {
+                        this.logger.warn(`[agent-runner] onStepFinish callback threw; ignoring: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                },
+            });
+            return { stopReason: 'natural' };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.warn(`[agent-runner] loop failed: ${err.message}`);
+            return { stopReason: 'error', error: err };
+        }
+    }
+}

package/node_modules/@ktx/context/dist/llm/claude-code-env.d.ts

@@ -0,0 +1,2 @@
+export declare const CLAUDE_CODE_PROVIDER_ENV_DENYLIST: readonly ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "ANTHROPIC_MODEL", "ANTHROPIC_VERTEX_PROJECT_ID", "CLOUD_ML_REGION", "GOOGLE_APPLICATION_CREDENTIALS", "GOOGLE_CLOUD_PROJECT", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN", "AWS_REGION", "AWS_PROFILE", "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX"];
+export declare function createKtxClaudeCodeEnv(env?: NodeJS.ProcessEnv): Record<string, string | undefined>;

package/node_modules/@ktx/context/dist/llm/claude-code-env.js

@@ -0,0 +1,21 @@
+export const CLAUDE_CODE_PROVIDER_ENV_DENYLIST = [
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
+    'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_MODEL',
+    'ANTHROPIC_VERTEX_PROJECT_ID',
+    'CLOUD_ML_REGION',
+    'GOOGLE_APPLICATION_CREDENTIALS',
+    'GOOGLE_CLOUD_PROJECT',
+    'AWS_ACCESS_KEY_ID',
+    'AWS_SECRET_ACCESS_KEY',
+    'AWS_SESSION_TOKEN',
+    'AWS_REGION',
+    'AWS_PROFILE',
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_VERTEX',
+];
+const DENYLIST = new Set(CLAUDE_CODE_PROVIDER_ENV_DENYLIST);
+export function createKtxClaudeCodeEnv(env = process.env) {
+    return Object.fromEntries(Object.entries(env).filter(([key]) => !DENYLIST.has(key)));
+}

package/node_modules/@ktx/context/dist/llm/claude-code-env.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@ktx/context/dist/llm/claude-code-env.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { CLAUDE_CODE_PROVIDER_ENV_DENYLIST, createKtxClaudeCodeEnv } from './claude-code-env.js';
+describe('createKtxClaudeCodeEnv', () => {
+    it('strips provider-routing credentials from the Claude Code child environment', () => {
+        const seeded = Object.fromEntries(CLAUDE_CODE_PROVIDER_ENV_DENYLIST.map((key) => [key, `${key}-value`]));
+        const env = createKtxClaudeCodeEnv({
+            ...seeded,
+            PATH: '/usr/bin',
+            HOME: '/Users/test',
+        });
+        for (const key of CLAUDE_CODE_PROVIDER_ENV_DENYLIST) {
+            expect(env).not.toHaveProperty(key);
+        }
+        expect(env.PATH).toBe('/usr/bin');
+        expect(env.HOME).toBe('/Users/test');
+    });
+});

package/node_modules/@ktx/context/dist/llm/claude-code-models.d.ts

@@ -0,0 +1 @@
+export declare function resolveClaudeCodeModel(model: string): string;

package/node_modules/@ktx/context/dist/llm/claude-code-models.js

@@ -0,0 +1,17 @@
+const CLAUDE_CODE_MODEL_ALIASES = {
+    sonnet: 'claude-sonnet-4-6',
+    opus: 'claude-opus-4-7',
+    haiku: 'claude-haiku-4-5',
+};
+const FULL_MODEL_ID = /^claude-(sonnet|opus|haiku)-[0-9]+-[0-9]+$/;
+export function resolveClaudeCodeModel(model) {
+    const normalized = model.trim();
+    const alias = CLAUDE_CODE_MODEL_ALIASES[normalized];
+    if (alias) {
+        return alias;
+    }
+    if (FULL_MODEL_ID.test(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unsupported Claude Code model "${model}". Use sonnet, opus, haiku, or a claude-* model id.`);
+}

package/node_modules/@ktx/context/dist/llm/claude-code-models.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@ktx/context/dist/llm/claude-code-models.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { resolveClaudeCodeModel } from './claude-code-models.js';
+describe('resolveClaudeCodeModel', () => {
+    it.each([
+        ['sonnet', 'claude-sonnet-4-6'],
+        ['opus', 'claude-opus-4-7'],
+        ['haiku', 'claude-haiku-4-5'],
+        ['claude-sonnet-4-6', 'claude-sonnet-4-6'],
+    ])('maps %s to %s', (input, expected) => {
+        expect(resolveClaudeCodeModel(input)).toBe(expected);
+    });
+    it('rejects unsupported aliases', () => {
+        expect(() => resolveClaudeCodeModel('gpt-5')).toThrow('Unsupported Claude Code model');
+    });
+});

package/node_modules/@ktx/context/dist/llm/claude-code-runtime.d.ts

@@ -0,0 +1,36 @@
+import { query as defaultQuery, type SDKMessage, type SDKResultMessage } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { type KtxLogger } from '../core/index.js';
+import type { KtxGenerateObjectInput, KtxGenerateTextInput, KtxLlmRuntimePort, RunLoopParams, RunLoopResult, RunLoopStopReason } from './runtime-port.js';
+type QueryFn = (params: Parameters<typeof defaultQuery>[0]) => AsyncIterable<SDKMessage>;
+export interface ClaudeCodeKtxLlmRuntimeDeps {
+    projectDir: string;
+    modelSlots: {
+        default: string;
+    } & Partial<Record<string, string>>;
+    query?: QueryFn;
+    env?: NodeJS.ProcessEnv;
+    logger?: KtxLogger;
+}
+export declare function mapClaudeCodeStopReason(result: SDKResultMessage): RunLoopStopReason;
+export declare class ClaudeCodeKtxLlmRuntime implements KtxLlmRuntimePort {
+    private readonly deps;
+    private readonly runQuery;
+    private readonly logger;
+    constructor(deps: ClaudeCodeKtxLlmRuntimeDeps);
+    generateText(input: KtxGenerateTextInput): Promise<string>;
+    generateObject<TOutput, TSchema extends z.ZodType<TOutput>>(input: KtxGenerateObjectInput<TOutput, TSchema>): Promise<TOutput>;
+    runAgentLoop(params: RunLoopParams): Promise<RunLoopResult>;
+}
+export declare function runClaudeCodeAuthProbe(input: {
+    projectDir: string;
+    model: string;
+    query?: QueryFn;
+    env?: NodeJS.ProcessEnv;
+}): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+}>;
+export {};

package/node_modules/@ktx/context/dist/llm/claude-code-runtime.js

@@ -0,0 +1,242 @@
+import { createSdkMcpServer, query as defaultQuery, } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { noopLogger } from '../core/index.js';
+import { createKtxClaudeCodeEnv } from './claude-code-env.js';
+import { resolveClaudeCodeModel } from './claude-code-models.js';
+import { createClaudeSdkTools, mcpToolIds } from './runtime-tools.js';
+const BUILTIN_TOOLS = [
+    'Agent',
+    'Task',
+    'AskUserQuestion',
+    'Bash',
+    'Read',
+    'Edit',
+    'Write',
+    'Glob',
+    'Grep',
+    'WebFetch',
+    'WebSearch',
+    'TodoWrite',
+];
+function isResult(message) {
+    return message.type === 'result';
+}
+function resultError(result) {
+    if (result.subtype === 'success') {
+        return undefined;
+    }
+    const details = result.errors.length > 0 ? `: ${result.errors.join('; ')}` : '';
+    return new Error(`Claude Code query failed (${result.subtype})${details}`);
+}
+export function mapClaudeCodeStopReason(result) {
+    if (result.subtype === 'error_max_turns') {
+        return 'budget';
+    }
+    if (result.terminal_reason === 'max_turns' || result.stop_reason === 'max_turns') {
+        return 'budget';
+    }
+    if (result.subtype === 'success') {
+        return result.terminal_reason && result.terminal_reason !== 'completed' ? 'error' : 'natural';
+    }
+    return 'error';
+}
+function jsonSchema(schema) {
+    return z.toJSONSchema(schema, { target: 'draft-7' });
+}
+function modelForRole(modelSlots, role) {
+    return resolveClaudeCodeModel(modelSlots[role] ?? modelSlots.default);
+}
+function assertInitIsolation(message, allowedToolIds, expectedMcpServerNames) {
+    if (message.type !== 'system' || message.subtype !== 'init') {
+        return;
+    }
+    const activeToolIds = new Set(message.tools);
+    const unexpectedTools = message.tools.filter((toolName) => !allowedToolIds.has(toolName));
+    const missingTools = [...allowedToolIds].filter((toolName) => !activeToolIds.has(toolName));
+    const activeMcpServerNames = message.mcp_servers.map((server) => server.name);
+    const unexpectedMcpServers = activeMcpServerNames.filter((name) => !expectedMcpServerNames.has(name));
+    const missingMcpServers = [...expectedMcpServerNames].filter((name) => !activeMcpServerNames.includes(name));
+    const unexpectedPlugins = message.plugins.map((plugin) => plugin.name);
+    if (unexpectedTools.length > 0 ||
+        missingTools.length > 0 ||
+        unexpectedMcpServers.length > 0 ||
+        missingMcpServers.length > 0 ||
+        unexpectedPlugins.length > 0) {
+        throw new Error(`Claude Code runtime isolation failed: tools=${unexpectedTools.join(',') || '(none)'} missing_tools=${missingTools.join(',') || '(none)'} mcp_servers=${unexpectedMcpServers.join(',') || '(none)'} missing_mcp_servers=${missingMcpServers.join(',') || '(none)'} plugins=${unexpectedPlugins.join(',') || '(none)'} host_slash_commands=${message.slash_commands.length} host_skills=${message.skills.length} host_agents=${message.agents?.join(',') || '(none)'}`);
+    }
+}
+function expectedMcpServerNames(tools) {
+    return tools && Object.keys(tools).length > 0 ? new Set(['ktx']) : new Set();
+}
+function baseOptions(input) {
+    const toolIds = mcpToolIds(input.tools ?? {});
+    const allowedToolIds = new Set(toolIds);
+    return {
+        cwd: input.projectDir,
+        model: input.model,
+        maxTurns: input.maxTurns,
+        settingSources: [],
+        skills: [],
+        plugins: [],
+        tools: [],
+        allowedTools: toolIds,
+        disallowedTools: BUILTIN_TOOLS,
+        canUseTool: async (toolName, _toolInput, options) => allowedToolIds.has(toolName)
+            ? { behavior: 'allow', toolUseID: options.toolUseID }
+            : {
+                behavior: 'deny',
+                message: `KTX claude-code runtime only permits current KTX MCP tools; denied ${toolName}.`,
+                toolUseID: options.toolUseID,
+            },
+        permissionMode: 'dontAsk',
+        persistSession: false,
+        env: createKtxClaudeCodeEnv(input.env),
+        ...(input.tools && Object.keys(input.tools).length > 0
+            ? { mcpServers: { ktx: createSdkMcpServer({ name: 'ktx', tools: createClaudeSdkTools(input.tools) }) } }
+            : {}),
+    };
+}
+async function collectResult(params) {
+    let result;
+    for await (const message of params.query({ prompt: params.prompt, options: params.options })) {
+        assertInitIsolation(message, params.allowedToolIds, params.expectedMcpServerNames);
+        if (message.type === 'assistant' && message.parent_tool_use_id === null) {
+            await params.onAssistantTurn?.();
+        }
+        if (isResult(message)) {
+            result = message;
+        }
+    }
+    if (!result) {
+        throw new Error('Claude Code query returned no result message');
+    }
+    return result;
+}
+export class ClaudeCodeKtxLlmRuntime {
+    deps;
+    runQuery;
+    logger;
+    constructor(deps) {
+        this.deps = deps;
+        this.runQuery = deps.query ?? defaultQuery;
+        this.logger = deps.logger ?? noopLogger;
+    }
+    async generateText(input) {
+        const options = baseOptions({
+            projectDir: this.deps.projectDir,
+            model: modelForRole(this.deps.modelSlots, input.role),
+            env: this.deps.env,
+            maxTurns: 1,
+            tools: input.tools,
+        });
+        const result = await collectResult({
+            query: this.runQuery,
+            prompt: [input.system, input.prompt].filter(Boolean).join('\n\n'),
+            options,
+            allowedToolIds: new Set(mcpToolIds(input.tools ?? {})),
+            expectedMcpServerNames: expectedMcpServerNames(input.tools),
+        });
+        const error = resultError(result);
+        if (error) {
+            throw error;
+        }
+        if (result.subtype !== 'success') {
+            throw new Error(`Claude Code query failed (${result.subtype})`);
+        }
+        return result.result;
+    }
+    async generateObject(input) {
+        const options = {
+            ...baseOptions({
+                projectDir: this.deps.projectDir,
+                model: modelForRole(this.deps.modelSlots, input.role),
+                env: this.deps.env,
+                maxTurns: 1,
+                tools: input.tools,
+            }),
+            outputFormat: { type: 'json_schema', schema: jsonSchema(input.schema) },
+        };
+        const result = await collectResult({
+            query: this.runQuery,
+            prompt: [input.system, input.prompt].filter(Boolean).join('\n\n'),
+            options,
+            allowedToolIds: new Set(mcpToolIds(input.tools ?? {})),
+            expectedMcpServerNames: expectedMcpServerNames(input.tools),
+        });
+        const error = resultError(result);
+        if (error) {
+            throw error;
+        }
+        if (result.subtype !== 'success') {
+            throw new Error(`Claude Code query failed (${result.subtype})`);
+        }
+        return input.schema.parse(result.structured_output);
+    }
+    async runAgentLoop(params) {
+        let stepIndex = 0;
+        try {
+            const options = baseOptions({
+                projectDir: this.deps.projectDir,
+                model: modelForRole(this.deps.modelSlots, params.modelRole),
+                env: this.deps.env,
+                maxTurns: params.stepBudget,
+                tools: params.toolSet,
+            });
+            const result = await collectResult({
+                query: this.runQuery,
+                prompt: params.userPrompt,
+                options: { ...options, systemPrompt: params.systemPrompt },
+                allowedToolIds: new Set(mcpToolIds(params.toolSet)),
+                expectedMcpServerNames: expectedMcpServerNames(params.toolSet),
+                onAssistantTurn: async () => {
+                    stepIndex += 1;
+                    if (!params.onStepFinish) {
+                        return;
+                    }
+                    try {
+                        await params.onStepFinish({ stepIndex, stepBudget: params.stepBudget });
+                    }
+                    catch (error) {
+                        this.logger.warn(`[claude-code-runner] onStepFinish callback threw; ignoring: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                },
+            });
+            const stopReason = mapClaudeCodeStopReason(result);
+            const error = resultError(result);
+            return { stopReason, ...(stopReason === 'error' && error ? { error } : {}) };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            return { stopReason: 'error', error: err };
+        }
+    }
+}
+export async function runClaudeCodeAuthProbe(input) {
+    try {
+        const options = baseOptions({
+            projectDir: input.projectDir,
+            model: resolveClaudeCodeModel(input.model),
+            env: input.env,
+            maxTurns: 1,
+        });
+        const result = await collectResult({
+            query: input.query ?? defaultQuery,
+            prompt: 'Reply with exactly: ok',
+            options,
+            allowedToolIds: new Set(),
+            expectedMcpServerNames: new Set(),
+        });
+        const error = resultError(result);
+        if (error) {
+            throw error;
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            message: `Claude Code authentication is not usable. Authenticate Claude Code locally with the Claude Code CLI, then rerun setup or the command. ${message}`,
+        };
+    }
+}

package/node_modules/@ktx/context/dist/llm/claude-code-runtime.test.d.ts

@@ -0,0 +1 @@
+export {};