maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.5.20260830

package/packages/eval/dist/install-preflight.js

@@ -1,201 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-import { execFile } from 'node:child_process';
-import { constants } from 'node:fs';
-import { access, lstat, stat } from 'node:fs/promises';
-import { dirname, isAbsolute, resolve } from 'node:path';
-import { BUNDLED_HARNESS_RELAY_ROOT, createHarnessPreparationEnvironment, resolvePathWithinRoot, resolveRealPathWithinRoot, } from './harness-environment.js';
-const PREFLIGHT_TIMEOUT_MS = 10_000;
-const PREFLIGHT_OUTPUT_LIMIT_BYTES = 16 * 1024;
-const PYTHON_FRAMEWORK_PROBE = [
-    'from importlib import import_module',
-    'from importlib.metadata import version',
-    'import sys',
-    'actual = version(sys.argv[1])',
-    'if actual != sys.argv[2]:',
-    '    raise SystemExit(f"installed {actual}, expected {sys.argv[2]}")',
-    'import_module(f"{sys.argv[3]}.models.trial.config")',
-].join('\n');
-export async function preflightHarnessInstallation(input, dependencies = {}) {
-    input.signal?.throwIfAborted();
-    const { framework, options, specPath } = input;
-    const pythonPath = pythonCommand(options.pythonPathEnv, specPath);
-    const trialsRoot = machinePath(options.trialsRootEnv);
-    if (isAbsolute(pythonPath)) {
-        await requirePath(pythonPath, `machine path ${options.pythonPathEnv}`, 'file');
-        await access(pythonPath, constants.X_OK).catch(() => {
-            throw new Error(`machine path ${options.pythonPathEnv} is not executable: ${pythonPath}`);
-        });
-    }
-    await requireUsableDirectory(trialsRoot, `machine path ${options.trialsRootEnv}`);
-    if (options.tasksRootEnv) {
-        await requirePath(machinePath(options.tasksRootEnv), `machine path ${options.tasksRootEnv}`, 'directory');
-    }
-    for (const mount of options.mounts) {
-        await requirePath(machinePath(mount.sourceEnv), `machine path ${mount.sourceEnv}`, 'any');
-    }
-    let networkPolicyPath;
-    if (options.egressProxy) {
-        const source = machinePath(options.egressProxy.composeSourceEnv);
-        await requirePath(source, `machine path ${options.egressProxy.composeSourceEnv}`, 'directory');
-        const composeCandidate = resolvePathWithinRoot(source, options.egressProxy.composeRelativePath, 'egress proxy compose path');
-        const networkPolicyCandidate = resolvePathWithinRoot(source, options.egressProxy.networkPolicyRelativePath, 'egress network policy path');
-        await requirePath(composeCandidate, 'Eval egress Compose overlay', 'file');
-        await requirePath(networkPolicyCandidate, 'Eval egress network policy', 'file');
-        [, networkPolicyPath] = await Promise.all([
-            resolveRealPathWithinRoot(source, options.egressProxy.composeRelativePath, 'egress proxy compose path'),
-            resolveRealPathWithinRoot(source, options.egressProxy.networkPolicyRelativePath, 'egress network policy path'),
-        ]);
-    }
-    for (const asset of ['eval_framework.py', 'relay_agent.py', 'run_trial.py']) {
-        await requirePath(resolve(BUNDLED_HARNESS_RELAY_ROOT, asset), `bundled Eval runtime ${asset}`, 'file');
-    }
-    input.signal?.throwIfAborted();
-    const runCommand = dependencies.runCommand ?? runCheckedCommand;
-    const environment = createHarnessPreparationEnvironment({
-        subjectCredentialNames: input.subjectCredentialNames,
-        declared: options.preparationEnvironment,
-        ...(options.egressProxy && networkPolicyPath
-            ? {
-                egress: {
-                    allowedHost: options.egressProxy.allowedHost,
-                    networkPolicyPath,
-                },
-            }
-            : {}),
-    });
-    const workingDirectory = dirname(specPath);
-    const distribution = framework === 'harbor' ? 'harbor' : 'datacurve-pier';
-    try {
-        await runCommand(pythonPath, ['-c', PYTHON_FRAMEWORK_PROBE, distribution, options.frameworkVersion, framework], environment, workingDirectory, input.signal);
-    }
-    catch (error) {
-        if (input.signal?.aborted)
-            input.signal.throwIfAborted();
-        throw new Error(`${framework} Python environment ${options.pythonPathEnv} is unavailable or does not provide ${distribution}@${options.frameworkVersion}: ${errorMessage(error)}`);
-    }
-    input.signal?.throwIfAborted();
-    if (options.environment.type === 'docker') {
-        try {
-            await runCommand('docker', ['version', '--format', '{{.Server.Version}}'], environment, workingDirectory, input.signal);
-        }
-        catch (error) {
-            if (input.signal?.aborted)
-                input.signal.throwIfAborted();
-            throw new Error(`Docker CLI or daemon is unavailable: ${errorMessage(error)}`);
-        }
-    }
-}
-async function runCheckedCommand(command, args, environment, cwd, signal) {
-    signal?.throwIfAborted();
-    await new Promise((resolvePromise, rejectPromise) => {
-        execFile(command, [...args], {
-            env: environment,
-            cwd,
-            timeout: PREFLIGHT_TIMEOUT_MS,
-            killSignal: 'SIGKILL',
-            maxBuffer: PREFLIGHT_OUTPUT_LIMIT_BYTES,
-            encoding: 'utf8',
-            ...(signal ? { signal } : {}),
-        }, (error, _stdout, stderr) => {
-            if (!error) {
-                resolvePromise();
-                return;
-            }
-            rejectPromise(new Error(stderr.trim() || error.message));
-        });
-    });
-}
-async function requirePath(path, label, expected) {
-    let metadata;
-    try {
-        metadata = await stat(path);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            throw new Error(`${label} does not exist: ${path}`);
-        }
-        throw new Error(`${label} is inaccessible: ${path}: ${errorMessage(error)}`);
-    }
-    if (expected === 'file' && !metadata.isFile())
-        throw new Error(`${label} is not a file: ${path}`);
-    if (expected === 'directory' && !metadata.isDirectory()) {
-        throw new Error(`${label} is not a directory: ${path}`);
-    }
-}
-async function requireUsableDirectory(path, label) {
-    let candidate = path;
-    while (true) {
-        let metadata;
-        try {
-            metadata = await stat(candidate);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                throw new Error(`${label} is inaccessible: ${candidate}: ${errorMessage(error)}`);
-            }
-            let linkMetadata;
-            try {
-                linkMetadata = await lstat(candidate);
-            }
-            catch (linkError) {
-                if (linkError.code !== 'ENOENT') {
-                    throw new Error(`${label} is inaccessible: ${candidate}: ${errorMessage(linkError)}`);
-                }
-            }
-            if (linkMetadata?.isSymbolicLink()) {
-                throw new Error(`${label} is a dangling symbolic link: ${candidate}`);
-            }
-            if (linkMetadata)
-                continue;
-            const parent = dirname(candidate);
-            if (parent === candidate) {
-                throw new Error(`${label} has no accessible parent directory: ${path}`);
-            }
-            candidate = parent;
-            continue;
-        }
-        if (!metadata.isDirectory()) {
-            const subject = candidate === path ? label : `${label} parent`;
-            throw new Error(`${subject} is not a directory: ${candidate}`);
-        }
-        await access(candidate, constants.W_OK | constants.X_OK).catch(() => {
-            const subject = candidate === path ? label : `${label} nearest existing parent`;
-            throw new Error(`${subject} is not writable and searchable: ${candidate}`);
-        });
-        return;
-    }
-}
-function machinePath(name) {
-    const value = process.env[name];
-    if (!value)
-        throw new Error(`machine path ${name} is unavailable`);
-    return resolve(value);
-}
-function pythonCommand(name, specPath) {
-    const value = process.env[name];
-    if (!value)
-        throw new Error(`machine path ${name} is unavailable`);
-    if (isAbsolute(value))
-        return value;
-    return value.includes('/') || value.includes('\\') ? resolve(dirname(specPath), value) : value;
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/packages/eval/dist/maka-artifacts.js

@@ -1,126 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-import { createHash, randomUUID } from 'node:crypto';
-import { createReadStream } from 'node:fs';
-import { chmod, copyFile, mkdir, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { basename, dirname, join, resolve } from 'node:path';
-import { backup, DatabaseSync } from 'node:sqlite';
-export const MAKA_RUNTIME_ARTIFACT_PATH = '/logs/artifacts/maka-runtime-host';
-export const MAKA_SUBJECT_STDOUT_PATH = '/logs/artifacts/maka-subject.stdout.txt';
-export const MAKA_SUBJECT_STDERR_PATH = '/logs/artifacts/maka-subject.stderr.txt';
-export async function captureMakaRuntimeArtifacts(input) {
-    const stateRoot = resolve(input.stateRoot);
-    const destinationRoot = resolve(input.destinationRoot);
-    const stagingRoot = `${destinationRoot}.${process.pid}.${randomUUID()}.tmp`;
-    await rm(stagingRoot, { recursive: true, force: true });
-    try {
-        await mkdir(stagingRoot, { recursive: true, mode: 0o700 });
-        const sourcePath = join(stateRoot, 'runtime.sqlite');
-        const destinationPath = join(stagingRoot, 'runtime.sqlite');
-        const source = new DatabaseSync(sourcePath, { readOnly: true });
-        try {
-            await backup(source, destinationPath);
-        }
-        finally {
-            source.close();
-        }
-        const snapshot = new DatabaseSync(destinationPath);
-        try {
-            snapshot.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-            snapshot.exec('PRAGMA journal_mode=DELETE');
-        }
-        finally {
-            snapshot.close();
-        }
-        await rm(`${destinationPath}-wal`, { force: true });
-        await rm(`${destinationPath}-shm`, { force: true });
-        await chmod(destinationPath, 0o600);
-        for (const name of ['runtime-host-candidate.log', 'runtime-policy.json']) {
-            const source = join(stateRoot, name);
-            try {
-                const metadata = await stat(source);
-                if (!metadata.isFile())
-                    continue;
-                const destination = join(stagingRoot, name);
-                await copyFile(source, destination);
-                await chmod(destination, 0o600);
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-            }
-        }
-        const files = await Promise.all(['runtime.sqlite', 'runtime-host-candidate.log', 'runtime-policy.json'].map((name) => describeFile(join(stagingRoot, name), name)));
-        const manifest = {
-            schemaVersion: 'maka.eval.runtime_artifacts.v1',
-            reason: input.reason,
-            capturedAt: (input.now ?? Date.now)(),
-            files: files.filter((file) => file !== null),
-        };
-        await writeFile(join(stagingRoot, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, {
-            flag: 'wx',
-            mode: 0o600,
-        });
-        await mkdir(dirname(destinationRoot), { recursive: true, mode: 0o700 });
-        await rm(destinationRoot, { recursive: true, force: true });
-        await rename(stagingRoot, destinationRoot);
-        return manifest;
-    }
-    catch (error) {
-        await rm(stagingRoot, { recursive: true, force: true }).catch(() => undefined);
-        throw error;
-    }
-}
-export async function writeMakaArtifactCollectionError(destinationRoot, error) {
-    const root = resolve(destinationRoot);
-    await mkdir(root, { recursive: true, mode: 0o700 });
-    await writeFile(join(root, 'collection-error.json'), `${JSON.stringify({
-        schemaVersion: 'maka.eval.runtime_artifact_error.v1',
-        errorCode: safeErrorCode(error),
-        message: safeErrorMessage(error),
-    })}\n`, { mode: 0o600 });
-}
-async function describeFile(path, name) {
-    try {
-        const metadata = await stat(path);
-        if (!metadata.isFile())
-            return null;
-        const hash = createHash('sha256');
-        for await (const chunk of createReadStream(path))
-            hash.update(chunk);
-        return {
-            path: basename(name),
-            bytes: metadata.size,
-            sha256: `sha256:${hash.digest('hex')}`,
-        };
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return null;
-        throw error;
-    }
-}
-function safeErrorCode(error) {
-    const code = error instanceof Error ? error.code : undefined;
-    return typeof code === 'string' && /^[A-Z0-9_]{1,64}$/u.test(code) ? code : null;
-}
-function safeErrorMessage(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return Buffer.from(message).subarray(0, 1024).toString();
-}

package/packages/eval/dist/maka-runtime-policy.js

@@ -1,42 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-import { createDefaultRuntimePolicy } from '@maka/core/runtime-policy';
-export function makaEvalRuntimePolicyDocument(proxyUrl) {
-    const policy = createDefaultRuntimePolicy();
-    const proxy = proxyUrl ? new URL(proxyUrl) : undefined;
-    return {
-        schemaVersion: 2,
-        revision: 0,
-        policy: {
-            ...policy,
-            ...(proxy
-                ? {
-                    networkProxy: {
-                        ...policy.networkProxy,
-                        enabled: true,
-                        protocol: 'http',
-                        host: proxy.hostname,
-                        port: Number(proxy.port || 80),
-                    },
-                }
-                : {}),
-            privacy: { incognitoActive: true },
-        },
-    };
-}

package/packages/eval/dist/maka-subject.js

@@ -1,268 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-import { randomUUID } from 'node:crypto';
-import { isSessionToolProfile } from '@maka/core/session';
-import { decodeHostedExecutionProjection } from '@maka/runtime-host/protocol';
-import { MAKA_RUNTIME_ARTIFACT_PATH, MAKA_SUBJECT_STDERR_PATH, MAKA_SUBJECT_STDOUT_PATH, } from './maka-artifacts.js';
-import { deepSeekCostUsd } from './provider-metering.js';
-export function createMakaSubjectAdapter() {
-    return {
-        kind: 'maka',
-        validate: (cell) => decodeConfig(cell.subject.config),
-        async execute({ cell, context }) {
-            const config = decodeConfig(cell.subject.config);
-            const executionId = randomUUID();
-            const input = {
-                executionId,
-                session: {
-                    workspace: { kind: 'host_path', path: context.cwd },
-                    modelTarget: {
-                        kind: 'explicit',
-                        connectionSlug: config.connectionSlug,
-                        model: config.model,
-                    },
-                    thinkingLevel: config.thinkingLevel,
-                    permissionMode: config.permissionMode,
-                    collaborationMode: config.collaborationMode,
-                    orchestrationMode: config.orchestrationMode,
-                    toolProfile: config.toolProfile,
-                },
-                content: { text: context.taskInput },
-                maxSteps: positive(cell.budget.maxSteps, 'budget.maxSteps'),
-            };
-            const payload = Buffer.from(JSON.stringify({
-                rootPath: `${config.runtimeHostsPath}/${executionId}`,
-                artifactRoot: MAKA_RUNTIME_ARTIFACT_PATH,
-                baseUrl: config.baseUrl,
-                hostSettlementTimeoutMs: config.hostSettlementTimeoutMs,
-                execution: input,
-            })).toString('base64url');
-            const startedAt = Date.now();
-            let process;
-            try {
-                process = await context.execute({
-                    command: config.nodePath,
-                    args: [config.shimPath, payload],
-                    credentialEnvironment: Object.fromEntries(cell.subject.credentials.map((name) => [name, name])),
-                });
-            }
-            catch {
-                return subjectFailure('relay-execute', startedAt, context.signal);
-            }
-            if (process.termination !== 'exited') {
-                const projection = tryDecodeMatchingProjection(process.stdout, executionId);
-                const settled = projection?.kind === 'settled' ? projection : undefined;
-                return {
-                    usage: settled?.usage ?? null,
-                    costUsd: settled ? estimateDeepSeekCost(settled.usage, config.model) : null,
-                    durationMs: Date.now() - startedAt,
-                    status: 'failed',
-                    failureReason: 'Maka subject exceeded the framework timeout',
-                    artifacts: makaArtifacts(executionId, process, settled?.costUsd),
-                };
-            }
-            if (process.stdout.length === 0) {
-                return subjectFailure('empty-output', startedAt, context.signal, process);
-            }
-            let parsed;
-            try {
-                parsed = JSON.parse(process.stdout);
-            }
-            catch {
-                return subjectFailure('json-parse', startedAt, context.signal, process);
-            }
-            let projection;
-            try {
-                projection = decodeHostedExecutionProjection(parsed);
-            }
-            catch {
-                return subjectFailure('result-decode', startedAt, context.signal, process);
-            }
-            if (projection.executionId !== executionId) {
-                return subjectFailure('identity-check', startedAt, context.signal, process);
-            }
-            if (projection.kind === 'indeterminate') {
-                return {
-                    usage: null,
-                    costUsd: null,
-                    durationMs: Date.now() - startedAt,
-                    status: 'indeterminate',
-                    failureReason: safeFailureReason(projection.failureReason, 'Maka execution did not settle'),
-                    artifacts: makaArtifacts(executionId, process),
-                };
-            }
-            const result = (status, failureReason) => ({
-                usage: projection.usage,
-                // Eval prices what Eval compares. The subject reports a cost of its
-                // own, from its own table, and taking it here would mean one arm
-                // billed at the runtime's rates and the others at this package's --
-                // a difference in the reported figure that no agent behaviour caused.
-                // It is kept as evidence below rather than used as the authority.
-                costUsd: estimateDeepSeekCost(projection.usage, config.model),
-                durationMs: Date.now() - startedAt,
-                status,
-                failureReason,
-                artifacts: makaArtifacts(executionId, process, projection.costUsd),
-            });
-            // The shim's exit code projects this same projection's status for the
-            // relay's benefit, so reading it here would only ask the same question
-            // twice and get a coarser answer. A shim that died without settling
-            // leaves no decodable projection, and the branches above catch that.
-            if (projection.status === 'cancelled') {
-                return result('indeterminate', 'Maka subject cancelled');
-            }
-            return result(projection.status, projection.status === 'completed' || projection.failureReason == null
-                ? null
-                : safeFailureReason(projection.failureReason, 'Maka execution failed'));
-        },
-    };
-}
-function tryDecodeMatchingProjection(stdout, executionId) {
-    if (stdout.length === 0)
-        return undefined;
-    try {
-        const projection = decodeHostedExecutionProjection(JSON.parse(stdout));
-        return projection.executionId === executionId ? projection : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function safeFailureReason(value, fallback) {
-    if (SAFE_RUNTIME_FAILURE_REASONS.has(value))
-        return value;
-    if (/^Runtime Host did not start: (?:composition_mismatch|existing_host|host_unresponsive|incompatible|startup_timeout|upgrade_required)$/u.test(value) ||
-        /^Runtime Host usage did not settle: (?:missing_attempt_usage|partial_attempt_usage|pending_usage_repair|unreadable_usage_record)$/u.test(value))
-        return value;
-    return fallback;
-}
-const SAFE_RUNTIME_FAILURE_REASONS = new Set([
-    'Hosted execution is not active',
-    'Hosted execution was cancelled',
-    'Hosted execution was cancelled before admission',
-    'Runtime Host connection failed before execution settlement',
-    'Runtime Host could not settle execution',
-    'Runtime Host did not exit cleanly',
-]);
-function subjectFailure(stage, startedAt, signal, process) {
-    const cancelled = signal?.aborted === true;
-    return {
-        usage: null,
-        costUsd: null,
-        durationMs: Date.now() - startedAt,
-        status: cancelled ? 'indeterminate' : 'infra_failed',
-        failureReason: cancelled ? 'Maka subject cancelled' : `Maka subject failed during ${stage}`,
-        artifacts: [
-            ...makaArtifacts(undefined, process),
-            {
-                kind: 'subject-failure',
-                stage,
-                ...(process
-                    ? {
-                        termination: process.termination,
-                        exitCode: process.exitCode,
-                        stdoutBytes: Buffer.byteLength(process.stdout),
-                        ...(process.diagnostic ? { diagnostic: process.diagnostic } : {}),
-                    }
-                    : {}),
-            },
-        ],
-    };
-}
-function makaArtifacts(executionId, process, 
-// What the subject billed itself, when it said. Recording it is what makes a
-// disagreement with Eval's own figure visible instead of silent -- the two
-// are computed from the same usage, so they should differ only when a price
-// table has drifted.
-subjectReportedCostUsd) {
-    return [
-        ...(subjectReportedCostUsd === undefined || subjectReportedCostUsd === null
-            ? []
-            : [{ kind: 'subject-reported-cost', costUsd: subjectReportedCostUsd }]),
-        {
-            kind: 'maka-runtime-state',
-            path: MAKA_RUNTIME_ARTIFACT_PATH,
-            ...(executionId ? { executionId } : {}),
-        },
-        {
-            kind: 'subject-stdout',
-            path: MAKA_SUBJECT_STDOUT_PATH,
-            ...(process ? { bytes: Buffer.byteLength(process.stdout) } : {}),
-        },
-        {
-            kind: 'subject-stderr',
-            path: MAKA_SUBJECT_STDERR_PATH,
-        },
-    ];
-}
-function decodeConfig(value) {
-    const fields = [
-        'nodePath',
-        'shimPath',
-        'runtimeHostsPath',
-        'baseUrl',
-        'connectionSlug',
-        'model',
-        'thinkingLevel',
-        'permissionMode',
-        'collaborationMode',
-        'orchestrationMode',
-        'hostSettlementTimeoutMs',
-        'toolProfile',
-    ];
-    const config = exact(value, fields);
-    if (!URL.canParse(String(config.baseUrl)))
-        throw new Error('Maka baseUrl is invalid');
-    const hostSettlementTimeoutMs = positiveInteger(config.hostSettlementTimeoutMs, 'Maka config.hostSettlementTimeoutMs');
-    if (!isSessionToolProfile(config.toolProfile)) {
-        throw new Error('Maka config.toolProfile is invalid');
-    }
-    return { ...config, hostSettlementTimeoutMs };
-}
-function exact(value, fields) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new Error('Maka config must be an object');
-    const record = value;
-    if (Object.keys(record).length !== fields.length ||
-        fields.some((field) => !Object.hasOwn(record, field)))
-        throw new Error('Maka config fields are invalid');
-    for (const field of fields) {
-        if (field === 'hostSettlementTimeoutMs')
-            continue;
-        if (typeof record[field] !== 'string' || record[field] === '')
-            throw new Error(`Maka config.${field} is invalid`);
-    }
-    return record;
-}
-function positiveInteger(value, where) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
-        throw new Error(`${where} is invalid`);
-    }
-    return value;
-}
-function positive(value, where) {
-    if (!Number.isSafeInteger(value) || value < 1)
-        throw new Error(`${where} is invalid`);
-    return value;
-}
-function estimateDeepSeekCost(usage, model) {
-    if (model !== 'deepseek-v4-flash')
-        return null;
-    return deepSeekCostUsd(usage);
-}