hoi4-agent-tools 3.0.8 → 3.1.0

package/dist/hoi4_agent_tools/mcp/transports/negotiated-stdio.js

@@ -0,0 +1,121 @@
+import { serveStdio } from '@modelcontextprotocol/server/stdio';
+import { createMcpServer } from '../server/create.js';
+import { createModernOperationServer } from '../server/create-modern-operations.js';
+import { BoundedStdioServerTransport, STDIO_MAX_FRAME_BYTES } from './bounded-stdio.js';
+import { FinalProtocolTransport } from './protocol-gate.js';
+const MAX_QUEUED_MESSAGES = 128;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Modern discovery or metadata selects the modern connection; initialize selects legacy. */
+export function isModernStdioOpening(message) {
+    if (!('method' in message))
+        return false;
+    if (message.method === 'server/discover')
+        return true;
+    if (message.method === 'initialize' || !('params' in message))
+        return false;
+    const params = message.params;
+    const meta = isRecord(params) ? params._meta : undefined;
+    return (isRecord(meta) && Object.keys(meta).some((key) => key.startsWith('io.modelcontextprotocol/')));
+}
+/** One logical SDK connection over the already-started bounded physical stream. */
+class PinnedStdioTransport {
+    physical;
+    reportError;
+    onclose = () => undefined;
+    onerror = () => undefined;
+    onmessage = () => undefined;
+    started = false;
+    queuedBytes = 0;
+    queue = [];
+    constructor(physical, reportError) {
+        this.physical = physical;
+        this.reportError = reportError;
+    }
+    receive(message) {
+        if (this.started) {
+            this.onmessage(message);
+            return;
+        }
+        const bytes = Buffer.byteLength(JSON.stringify(message)) + 1;
+        if (this.queue.length >= MAX_QUEUED_MESSAGES ||
+            bytes > STDIO_MAX_FRAME_BYTES - this.queuedBytes) {
+            const error = new Error('Stdio negotiation queue exceeded its bounded limit');
+            this.reportError(error);
+            this.onerror(error);
+            void this.physical.close();
+            return;
+        }
+        this.queue.push(message);
+        this.queuedBytes += bytes;
+    }
+    start() {
+        if (this.started)
+            throw new Error('Negotiated stdio transport already started');
+        this.started = true;
+        for (const message of this.queue.splice(0))
+            this.onmessage(message);
+        this.queuedBytes = 0;
+        return Promise.resolve();
+    }
+    send(message) {
+        return this.physical.send(message);
+    }
+    close() {
+        return this.physical.close();
+    }
+}
+/** Pin the protocol generation on the first message while retaining the old bounded wire. */
+export async function serveNegotiatedStdio(engine, options) {
+    const physical = new BoundedStdioServerTransport({
+        ...(options.stdin === undefined ? {} : { stdin: options.stdin }),
+        ...(options.stdout === undefined ? {} : { stdout: options.stdout }),
+    });
+    let pinned;
+    const reportedErrors = new WeakSet();
+    const reportError = (error) => {
+        if (reportedErrors.has(error))
+            return;
+        reportedErrors.add(error);
+        options.onerror(error);
+    };
+    physical.onclose = () => pinned?.onclose();
+    physical.onerror = (error) => {
+        reportError(error);
+        pinned?.onerror(error);
+    };
+    physical.onmessage = (message) => {
+        if (pinned === undefined) {
+            pinned = new PinnedStdioTransport(physical, reportError);
+            try {
+                if (isModernStdioOpening(message)) {
+                    serveStdio(() => createModernOperationServer(engine, {}, undefined, options.createModernPrivateTools === undefined
+                        ? {}
+                        : { createPrivateTools: options.createModernPrivateTools }), {
+                        transport: pinned,
+                        legacy: 'reject',
+                        onerror: reportError,
+                    });
+                }
+                else {
+                    const server = createMcpServer(engine, {});
+                    options.registerLegacy?.(server);
+                    server.server.onerror = reportError;
+                    void server.connect(new FinalProtocolTransport(pinned)).catch((error) => {
+                        options.onFailure(error);
+                        void physical.close();
+                    });
+                }
+            }
+            catch (error) {
+                options.onFailure(error);
+                void physical.close();
+                return;
+            }
+        }
+        pinned.receive(message);
+    };
+    await physical.start();
+    return physical;
+}

package/dist/hoi4_agent_tools/probability/job-operations.js

@@ -0,0 +1,58 @@
+import { z } from 'zod/v4';
+import { IdleCacheLifetime } from '../core/idle-cache-lifetime.js';
+import { errorResult, toolResult } from '../core/operation-result.js';
+import { ServiceError } from '../core/result.js';
+import { probabilityCompareRequestSchema, probabilityEvaluateRequestSchema, probabilityInspectRequestSchema, probabilityRenderRequestSchema, probabilitySequenceRequestSchema, probabilitySimulateRequestSchema, probabilitySweepRequestSchema, } from '../schemas/probability-requests.js';
+import { compareProbabilities, evaluateProbabilities, inspectProbabilities, normalizeProbabilityCompareRequest, normalizeProbabilityEvaluateRequest, normalizeProbabilityInspectRequest, normalizeProbabilityRenderRequest, normalizeProbabilitySequenceRequest, normalizeProbabilitySimulateRequest, normalizeProbabilitySweepRequest, renderProbabilities, sequenceProbabilities, simulateProbabilities, sweepProbabilities, } from './operations.js';
+import { ProbabilityAnalyzer } from './service.js';
+const wireResult = z.record(z.string(), z.json());
+/** Registers probability operations without invoking transport handlers. */
+export function registerProbabilityJobs(operations, engine) {
+    const analyzer = new ProbabilityAnalyzer(engine);
+    const lifetime = new IdleCacheLifetime(() => analyzer.clearCaches());
+    function register(name, schema, normalize, execute, message) {
+        operations.registerRead(name, schema, async (input, context) => {
+            const release = lifetime.begin();
+            try {
+                if (input.workspaceId !== 'current' && input.workspaceId !== context.workspaceId)
+                    throw new ServiceError('JOB_ARGUMENT_SCOPE_MISMATCH', 'The request workspace does not match the authorized job workspace');
+                await context.progress({ completed: 0, total: 3, message });
+                const result = await execute(analyzer, normalize(input), {
+                    workspaceId: context.workspaceId,
+                    ...(context.principal === undefined ? {} : { principal: context.principal }),
+                    signal: context.signal,
+                });
+                await context.progress({
+                    completed: 3,
+                    total: 3,
+                    message: 'Probability operation complete',
+                });
+                const wire = wireResult.parse(JSON.parse(JSON.stringify(toolResult(result))));
+                const revision = result.data !== null &&
+                    typeof result.data === 'object' &&
+                    'sourceRevision' in result.data &&
+                    typeof result.data.sourceRevision === 'string'
+                    ? result.data.sourceRevision
+                    : undefined;
+                if (revision !== undefined)
+                    await context.stageResult(wire, { sourceRevision: revision });
+                return wire;
+            }
+            catch (error) {
+                if (context.signal.aborted)
+                    throw error;
+                return wireResult.parse(JSON.parse(JSON.stringify(errorResult(error, context.workspaceId))));
+            }
+            finally {
+                release();
+            }
+        });
+    }
+    register('hoi4.probability_inspect', probabilityInspectRequestSchema, normalizeProbabilityInspectRequest, inspectProbabilities, 'Inspecting weighted source');
+    register('hoi4.probability_evaluate', probabilityEvaluateRequestSchema, normalizeProbabilityEvaluateRequest, evaluateProbabilities, 'Evaluating weighted scenarios');
+    register('hoi4.probability_sweep', probabilitySweepRequestSchema, normalizeProbabilitySweepRequest, sweepProbabilities, 'Evaluating parameter sweep');
+    register('hoi4.probability_simulate', probabilitySimulateRequestSchema, normalizeProbabilitySimulateRequest, simulateProbabilities, 'Sampling uncertain scenarios');
+    register('hoi4.probability_sequence', probabilitySequenceRequestSchema, normalizeProbabilitySequenceRequest, sequenceProbabilities, 'Analyzing declared sequence');
+    register('hoi4.probability_compare', probabilityCompareRequestSchema, normalizeProbabilityCompareRequest, compareProbabilities, 'Comparing weighted source');
+    register('hoi4.probability_render', probabilityRenderRequestSchema, normalizeProbabilityRenderRequest, renderProbabilities, 'Rendering analysis resources');
+}

package/dist/hoi4_agent_tools/probability/operations.js

@@ -0,0 +1,183 @@
+import { emptyServiceResult } from '../core/result.js';
+import { setInlineFilesScanned } from '../core/operation-result.js';
+import { probabilityCompareRequestSchema, probabilityEvaluateRequestSchema, probabilityInspectRequestSchema, probabilityRenderRequestSchema, probabilitySequenceRequestSchema, probabilitySimulateRequestSchema, probabilitySweepRequestSchema, } from '../schemas/probability-requests.js';
+function runtime(context, refresh) {
+    return {
+        workspaceId: context.workspaceId,
+        ...(context.principal === undefined ? {} : { principal: context.principal }),
+        ...(context.signal === undefined ? {} : { signal: context.signal }),
+        ...(refresh === undefined ? {} : { refresh }),
+    };
+}
+export function probabilityAnalysisData(result) {
+    return {
+        operation: result.operation,
+        analysisId: result.analysisId,
+        analysisStatus: result.status,
+        adapterId: result.adapter.id,
+        sourceRevision: result.metadata.sourceRevision,
+        sourceHash: result.metadata.sourceHash,
+        scenarioHash: result.metadata.scenarioHash,
+        cacheKey: result.metadata.cacheKey,
+        scenarios: result.scenarios.length,
+        candidates: result.scenarios.reduce((sum, scenario) => sum + scenario.candidates.length, 0),
+        ...(result.scenarios.some(({ scopePools }) => (scopePools?.length ?? 0) > 0)
+            ? {
+                scopePools: result.scenarios.reduce((sum, scenario) => sum + (scenario.scopePools?.length ?? 0), 0),
+                scopePoolCandidates: result.scenarios.reduce((sum, scenario) => sum +
+                    (scenario.scopePools?.reduce((poolSum, pool) => poolSum + pool.candidates.length, 0) ?? 0), 0),
+            }
+            : {}),
+        unresolved: result.unresolved.length,
+        diagnostics: result.diagnostics.length,
+        ...(result.sweep === undefined ? {} : { sweepPoints: result.sweep.points.length }),
+        ...(result.metadata.samples === undefined ? {} : { samples: result.metadata.samples }),
+        ...(result.sequence === undefined ? {} : { sequenceMethod: result.sequence.method }),
+        ...(result.comparison === undefined
+            ? {}
+            : { comparisonChanges: result.comparison.scenarioChanges.length }),
+        visualResources: result.resources.filter(({ mimeType }) => mimeType.startsWith('image/'))
+            .length,
+    };
+}
+export function probabilityAnalysisServiceResult(workspaceId, result) {
+    const output = emptyServiceResult(workspaceId, probabilityAnalysisData(result));
+    output.code =
+        result.status === 'complete'
+            ? 'PROBABILITY_ANALYZED'
+            : result.status === 'stale'
+                ? result.diagnostics.some(({ code }) => code === 'PROBABILITY_SCENARIO_STALE')
+                    ? 'PROBABILITY_SCENARIO_STALE'
+                    : 'PROBABILITY_ANALYSIS_STALE'
+                : 'PROBABILITY_ANALYZED_PARTIAL';
+    output.artifacts = result.resources;
+    output.diagnostics = result.diagnostics;
+    output.validation = {
+        passed: result.status !== 'blocked' && result.status !== 'cancelled',
+        checks: [
+            {
+                id: 'uncertainty-visible',
+                passed: true,
+                message: `${result.unresolved.length} unresolved or bounded analysis item(s) are explicit`,
+            },
+        ],
+    };
+    return output;
+}
+export function normalizeProbabilityInspectRequest(input) {
+    return probabilityInspectRequestSchema.parse(input);
+}
+export function normalizeProbabilityEvaluateRequest(input) {
+    return probabilityEvaluateRequestSchema.parse(input);
+}
+export function normalizeProbabilitySweepRequest(input) {
+    return probabilitySweepRequestSchema.parse(input);
+}
+export function normalizeProbabilitySimulateRequest(input) {
+    return probabilitySimulateRequestSchema.parse(input);
+}
+export function normalizeProbabilitySequenceRequest(input) {
+    return probabilitySequenceRequestSchema.parse(input);
+}
+export function normalizeProbabilityCompareRequest(input) {
+    return probabilityCompareRequestSchema.parse(input);
+}
+export function normalizeProbabilityRenderRequest(input) {
+    return probabilityRenderRequestSchema.parse(input);
+}
+export async function inspectProbabilities(analyzer, input, context) {
+    const inspected = await analyzer.inspect(runtime(context, input.refresh), input.adapter, input.source, input.candidatePool, input.customPoolManifest);
+    const result = emptyServiceResult(context.workspaceId, {
+        adapters: inspected.adapters.length,
+        ...(inspected.surface === undefined
+            ? {}
+            : {
+                adapterId: inspected.surface.adapter.id,
+                sourceRevision: inspected.surface.sourceRevision,
+                sourceHash: inspected.surface.sourceHash,
+                poolComplete: inspected.surface.poolComplete,
+            }),
+        ...(inspected.discovery === undefined
+            ? {}
+            : {
+                ...(inspected.discovery.requestedAdapter === undefined
+                    ? {}
+                    : { requestedAdapter: inspected.discovery.requestedAdapter }),
+                ...(inspected.discovery.suggestedAdapter === undefined
+                    ? {}
+                    : { suggestedAdapter: inspected.discovery.suggestedAdapter }),
+                discoveryReason: inspected.discovery.reason,
+                sourceRevision: inspected.discovery.sourceRevision,
+                sourceHash: inspected.discovery.sourceHash,
+            }),
+        candidates: inspected.surface?.candidateCount ?? 0,
+        availableCandidates: inspected.discovery?.availableAdapters.reduce((sum, { candidateCount }) => sum + candidateCount, 0) ?? 0,
+        availableAdapters: inspected.discovery?.availableAdapters.map((available) => ({
+            adapterId: available.adapterId,
+            candidates: available.candidateCount,
+            identifierMatches: available.identifierMatchCount,
+            candidatePoolMatches: available.candidatePoolMatchCount,
+        })) ?? [],
+        candidateExamples: inspected.discovery?.exampleCandidateIds ?? [],
+        requiredInputs: inspected.surface?.requiredInputs.length ?? 0,
+        unresolved: inspected.surface?.unsupported.length ?? 0,
+    });
+    result.code =
+        inspected.surface !== undefined
+            ? 'PROBABILITY_SOURCE_INSPECTED'
+            : inspected.discovery !== undefined
+                ? 'PROBABILITY_SOURCE_DISCOVERED'
+                : 'PROBABILITY_ADAPTERS_LISTED';
+    result.artifacts = inspected.artifacts;
+    setInlineFilesScanned(result, inspected.filesScanned);
+    return result;
+}
+export async function evaluateProbabilities(analyzer, input, context) {
+    const analyzed = await analyzer.evaluate({
+        ...runtime(context, input.refresh),
+        ...input,
+        workspaceId: context.workspaceId,
+    });
+    return probabilityAnalysisServiceResult(context.workspaceId, analyzed);
+}
+export async function sweepProbabilities(analyzer, input, context) {
+    const analyzed = await analyzer.sweep({
+        ...runtime(context, input.refresh),
+        ...input,
+        workspaceId: context.workspaceId,
+    });
+    return probabilityAnalysisServiceResult(context.workspaceId, analyzed);
+}
+export async function simulateProbabilities(analyzer, input, context) {
+    const analyzed = await analyzer.simulate({
+        ...runtime(context, input.refresh),
+        ...input,
+        workspaceId: context.workspaceId,
+    });
+    return probabilityAnalysisServiceResult(context.workspaceId, analyzed);
+}
+export async function sequenceProbabilities(analyzer, input, context) {
+    const analyzed = await analyzer.sequence({
+        ...runtime(context),
+        ...input,
+        workspaceId: context.workspaceId,
+    });
+    return probabilityAnalysisServiceResult(context.workspaceId, analyzed);
+}
+export async function compareProbabilities(analyzer, input, context) {
+    const analyzed = await analyzer.compare({
+        ...runtime(context, input.refresh),
+        ...input,
+        workspaceId: context.workspaceId,
+    });
+    return probabilityAnalysisServiceResult(context.workspaceId, analyzed);
+}
+export async function renderProbabilities(analyzer, input, context) {
+    const analyzed = await analyzer.render({
+        ...runtime(context),
+        ...input,
+        workspaceId: context.workspaceId,
+        outputs: input.outputs.filter((output) => output !== 'json'),
+    });
+    return probabilityAnalysisServiceResult(context.workspaceId, analyzed);
+}

package/dist/hoi4_agent_tools/probability/scenario-state.js

@@ -1,98 +1,5 @@
-function caseInsensitiveEntry(record, key) {
-    if (record === undefined)
-        return undefined;
-    if (Object.hasOwn(record, key))
-        return record[key];
-    const normalized = key.toLowerCase();
-    const found = Object.entries(record).find(([candidate]) => candidate.toLowerCase() === normalized);
-    return found?.[1];
-}
-export function rootScopeContext(scenario) {
-    return {
-        expression: 'ROOT',
-        binding: {
-            id: scenario.actor ?? 'ROOT',
-            ...(scenario.actor === undefined ? {} : { actor: scenario.actor }),
-            state: scenario.state,
-            ...(scenario.flags === undefined ? {} : { flags: scenario.flags }),
-            ...(scenario.eventTargets === undefined ? {} : { eventTargets: scenario.eventTargets }),
-        },
-    };
-}
-function explicitScope(scenario, expression, parent) {
-    const binding = caseInsensitiveEntry(scenario.scopes, expression);
-    return binding === undefined ? undefined : { expression, binding, parent };
-}
-export function resolveScopeContext(scenario, expression, current) {
-    const upper = expression.toUpperCase();
-    if (upper === 'ROOT')
-        return rootScopeContext(scenario);
-    if (upper === 'THIS')
-        return current;
-    if (upper === 'PREV')
-        return current.parent ?? rootScopeContext(scenario);
-    const chained = current.expression === 'ROOT' || current.expression === 'THIS'
-        ? expression
-        : `${current.expression}.${expression}`;
-    const chainedBinding = explicitScope(scenario, chained, current);
-    if (chainedBinding !== undefined)
-        return chainedBinding;
-    const direct = explicitScope(scenario, expression, current);
-    if (direct !== undefined)
-        return direct;
-    const targetMatch = /^(?:event_target|scope):(.+)$/iu.exec(expression);
-    const targetId = targetMatch === null
-        ? undefined
-        : (caseInsensitiveEntry(current.binding.eventTargets, targetMatch[1]) ??
-            caseInsensitiveEntry(scenario.eventTargets, targetMatch[1]));
-    if (targetId !== undefined) {
-        const declaredBinding = Object.values(scenario.scopes ?? {}).find((binding) => binding.id === targetId || binding.actor === targetId);
-        return {
-            expression,
-            binding: declaredBinding ?? { id: targetId, actor: targetId, state: {} },
-            parent: current,
-        };
-    }
-    return undefined;
-}
-export function scopeStateValue(scenario, key, current) {
-    if (Object.hasOwn(current.binding.state, key))
-        return current.binding.state[key];
-    if (Object.hasOwn(current.binding.state, `trigger.${key}`))
-        return current.binding.state[`trigger.${key}`];
-    if (current.expression !== 'ROOT')
-        return undefined;
-    if (Object.hasOwn(scenario.state, key))
-        return scenario.state[key];
-    if (Object.hasOwn(scenario.state, `trigger.${key}`))
-        return scenario.state[`trigger.${key}`];
-    return undefined;
-}
-export function rootStateValue(scenario, key) {
-    if (Object.hasOwn(scenario.state, key))
-        return scenario.state[key];
-    if (Object.hasOwn(scenario.state, `trigger.${key}`))
-        return scenario.state[`trigger.${key}`];
-    return undefined;
-}
-export function scopeIdentity(current) {
-    return current.binding.actor ?? current.binding.id;
-}
-export function scopedExpressionValue(scenario, expression) {
-    const scopes = Object.entries(scenario.scopes ?? {}).sort(([left], [right]) => right.length - left.length);
-    for (const [scope, binding] of scopes) {
-        for (const prefix of [`${scope}.`, `scope.${scope}.`, `scopes.${scope}.`]) {
-            if (!expression.toLowerCase().startsWith(prefix.toLowerCase()))
-                continue;
-            const key = expression.slice(prefix.length).replace(/^state\./u, '');
-            if (Object.hasOwn(binding.state, key))
-                return binding.state[key];
-            if (Object.hasOwn(binding.state, `variable.${key}`))
-                return binding.state[`variable.${key}`];
-        }
-    }
-    return undefined;
-}
+import { rootStateValue, scopedExpressionValue } from '../core/scenario-state.js';
+export { rootScopeContext, resolveScopeContext, scopeStateValue, rootStateValue, scopeIdentity, scopedExpressionValue, } from '../core/scenario-state.js';
 function updateScopeState(scenario, path, value) {
     const scopes = Object.entries(scenario.scopes ?? {}).sort(([left], [right]) => right.length - left.length);
     for (const [scope, binding] of scopes) {

package/dist/hoi4_agent_tools/probability/service.js

@@ -6,6 +6,7 @@ import { probabilityDomainScanPatterns, probabilitySharedDefinitionPatterns, } f
 import { publicArtifactLink } from '../core/artifacts.js';
 import { ServiceError } from '../core/result.js';
 import { PACKAGE_VERSION } from '../version.js';
+import { probabilityAnalysisResultSchema } from '../schemas/probability.js';
 import { probabilityAdapter, probabilityAdapters } from './adapters.js';
 import { compareProbabilityResults } from './compare.js';
 import { evaluateExactCandidates, evaluateSurfaceScenarios } from './evaluation.js';
@@ -710,6 +711,28 @@ export class ProbabilityAnalyzer {
         this.state.byCacheKey.clear();
         this.engine.releaseScanCaches();
     }
+    async retainedAnalysis(request) {
+        const workspace = this.engine.resolver.get(request.workspaceId, request.principal);
+        const candidates = (await this.engine.artifacts.list(workspace, request.signal)).filter(({ name }) => name === `${request.analysisId}.json`);
+        for (const artifact of candidates) {
+            request.signal?.throwIfAborted();
+            try {
+                const logical = await this.engine.artifacts.readLogical(workspace, artifact.uri, { mimeType: 'application/json', maxBytes: 134_217_728, maxChunks: 2_048 }, request.signal);
+                const result = probabilityAnalysisResultSchema.parse(JSON.parse(logical.bytes.toString('utf8')));
+                if (result.analysisId !== request.analysisId ||
+                    result.metadata.workspaceId !== request.workspaceId ||
+                    result.operation === 'render')
+                    continue;
+                rememberAnalysis(this.state, result);
+                return result;
+            }
+            catch (error) {
+                if (error instanceof ServiceError && error.code === 'ARTIFACT_WORKSPACE_MISMATCH')
+                    throw error;
+            }
+        }
+        throw new ServiceError('PROBABILITY_ANALYSIS_NOT_CACHED', 'Render requires a retained analysis ID from this authorized workspace', { analysisId: request.analysisId });
+    }
     async scan(context, sourcePaths = [], emptyScope = 'domain') {
         if (context.refresh === true)
             this.engine.invalidate(context.workspaceId);
@@ -1394,9 +1417,7 @@ export class ProbabilityAnalyzer {
         return this.store(result, request.outputs ?? ['json', 'comparison'], false, request.signal, request.principal);
     }
     async render(request) {
-        const result = this.state.byId.get(request.analysisId);
-        if (result === undefined)
-            throw new ServiceError('PROBABILITY_ANALYSIS_NOT_CACHED', 'Render requires an analysis ID produced by this server process', { analysisId: request.analysisId });
+        const result = this.state.byId.get(request.analysisId) ?? (await this.retainedAnalysis(request));
         if (result.metadata.workspaceId !== request.workspaceId)
             throw new ServiceError('PROBABILITY_ANALYSIS_WORKSPACE_MISMATCH', 'Analysis belongs to a different workspace');
         if (request.expectedScenarioHash !== undefined &&