hoi4-agent-tools 3.0.9 → 3.2.0

package/dist/hoi4_agent_tools/mcp/tools/probability.js

@@ -1,176 +1,9 @@
+import { registerLegacyTaskTools } from '../server/legacy-task-tools.js';
+import { probabilityPrompt, probabilityPromptArguments, probabilityPromptDefinition, } from '../prompts/probability.js';
 import { z } from 'zod/v4';
-import { IdleCacheLifetime } from '../../core/idle-cache-lifetime.js';
-import { emptyServiceResult } from '../../core/result.js';
-import { ProbabilityAnalyzer, } from '../../probability/service.js';
-import { customWeightedPoolManifestSchema, probabilityAcceptanceBandSchema, probabilityAdapterIdSchema, probabilityDiagnosticThresholdsSchema, probabilityMetricSchema, probabilityOutputSchema, probabilityRenderFilterSchema, probabilityScenarioSetSchema, probabilitySamplingMethodSchema, probabilitySourceSchema, } from '../../schemas/probability.js';
-import { workspaceIdSchema } from '../../schemas/common.js';
-import { resolveServerWorkspaceId } from '../server/base-tools.js';
-import { compactValidatedInputSchema } from '../server/context-schemas.js';
+import { probabilityCompareRequestSchema, probabilityEvaluateRequestSchema, probabilityInspectRequestSchema, probabilityRenderRequestSchema, probabilitySequenceRequestSchema, probabilitySimulateRequestSchema, probabilitySweepRequestSchema, } from '../../schemas/probability-requests.js';
 import { nonNegativeIntegerSchema, sha256Schema } from '../server/output-schemas.js';
-import { progressReporter } from '../server/progress.js';
-import { errorResult, setInlineFilesScanned, strictOperationResultSchema, toolResult, } from '../server/result.js';
-const nestedSource = compactValidatedInputSchema(probabilitySourceSchema, 'Source selector or proposed source.');
-const nestedScenarios = compactValidatedInputSchema(probabilityScenarioSetSchema, 'Explicit world-state scenarios.');
-const nestedManifest = compactValidatedInputSchema(customWeightedPoolManifestSchema, 'Declared custom weighted pool and state transitions.');
-const nestedRenderFilter = compactValidatedInputSchema(probabilityRenderFilterSchema, 'Optional scenario, candidate, metric, diagnostic, source, and page filter.');
-const nestedAcceptanceBands = compactValidatedInputSchema(z.array(probabilityAcceptanceBandSchema).max(100_000), 'Optional named metric acceptance bands.');
-const nestedDiagnosticThresholds = compactValidatedInputSchema(probabilityDiagnosticThresholdsSchema, 'Optional diagnostic thresholds.');
-const candidatePool = z.array(z.string().min(1).max(512)).max(100_000).optional();
-const outputs = z.array(probabilityOutputSchema).max(10).optional();
-const commonShape = {
-    workspaceId: workspaceIdSchema,
-    adapter: probabilityAdapterIdSchema.optional(),
-    scenarioSet: nestedScenarios,
-    candidatePool,
-    horizonDays: z.number().positive().max(1_000_000).optional(),
-    metrics: z.array(probabilityMetricSchema).min(1).max(4).optional(),
-    acceptanceBands: nestedAcceptanceBands.optional(),
-    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
-    outputs,
-    refresh: z.boolean().optional(),
-};
-const inspectInput = z
-    .object({
-    workspaceId: workspaceIdSchema,
-    adapter: probabilityAdapterIdSchema.optional(),
-    source: nestedSource.optional(),
-    customPoolManifest: nestedManifest.optional(),
-    candidatePool,
-    refresh: z.boolean().optional(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if (value.source !== undefined && value.customPoolManifest !== undefined)
-        context.addIssue({
-            code: 'custom',
-            message: 'Provide either source or customPoolManifest',
-        });
-    if (value.adapter !== undefined &&
-        value.source === undefined &&
-        value.customPoolManifest === undefined)
-        context.addIssue({
-            code: 'custom',
-            message: 'An adapter requires a source; provide a source alone to discover compatible adapters',
-        });
-    if (value.customPoolManifest !== undefined &&
-        value.adapter !== undefined &&
-        value.adapter !== 'custom_weighted_pool')
-        context.addIssue({
-            code: 'custom',
-            path: ['adapter'],
-            message: 'customPoolManifest requires adapter custom_weighted_pool',
-        });
-});
-const evaluateInput = z
-    .object({
-    ...commonShape,
-    source: nestedSource.optional(),
-    customPoolManifest: nestedManifest.optional(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if ((value.source === undefined) === (value.customPoolManifest === undefined))
-        context.addIssue({
-            code: 'custom',
-            message: 'Provide exactly one source or customPoolManifest',
-        });
-    if (value.customPoolManifest !== undefined &&
-        value.adapter !== undefined &&
-        value.adapter !== 'custom_weighted_pool')
-        context.addIssue({
-            code: 'custom',
-            path: ['adapter'],
-            message: 'customPoolManifest requires adapter custom_weighted_pool',
-        });
-});
-const sweepInput = z
-    .object({
-    ...commonShape,
-    source: nestedSource,
-    sweep: z
-        .object({
-        paths: z.array(z.string().min(1).max(1024)).min(1).max(32),
-        steps: z.number().int().min(2).max(10_000).default(25),
-        pairwise: z.boolean().default(false),
-        findRankReversals: z.boolean().default(true),
-    })
-        .strict(),
-})
-    .strict();
-const simulateInput = z
-    .object({
-    ...commonShape,
-    source: nestedSource,
-    samples: z.number().int().min(100).max(10_000_000).default(100_000),
-    seed: z.number().int().min(-2_147_483_648).max(2_147_483_647).default(1),
-    confidenceLevel: z.number().min(0.5).max(0.9999).default(0.95),
-    samplingMethod: probabilitySamplingMethodSchema.default('latin_hypercube'),
-})
-    .strict();
-const sequenceInput = z
-    .object({
-    workspaceId: workspaceIdSchema,
-    scenarioSet: nestedScenarios,
-    customPoolManifest: nestedManifest,
-    horizonDays: z.number().positive().max(1_000_000),
-    maxSteps: z.number().int().min(1).max(100_000).default(1_000),
-    samples: z.number().int().min(100).max(10_000_000).default(100_000),
-    seed: z.number().int().min(-2_147_483_648).max(2_147_483_647).default(1),
-    confidenceLevel: z.number().min(0.5).max(0.9999).default(0.95),
-    acceptanceBands: nestedAcceptanceBands.optional(),
-    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
-    outputs,
-})
-    .strict();
-const compareInput = z
-    .object({
-    workspaceId: workspaceIdSchema,
-    adapter: probabilityAdapterIdSchema.optional(),
-    before: nestedSource.optional(),
-    after: nestedSource.optional(),
-    beforeManifest: nestedManifest.optional(),
-    afterManifest: nestedManifest.optional(),
-    scenarioSet: nestedScenarios,
-    candidatePool,
-    horizonDays: z.number().positive().max(1_000_000).optional(),
-    acceptanceBands: nestedAcceptanceBands.optional(),
-    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
-    outputs,
-    refresh: z.boolean().optional(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    const sourceMode = value.before !== undefined || value.after !== undefined;
-    const manifestMode = value.beforeManifest !== undefined || value.afterManifest !== undefined;
-    if (sourceMode === manifestMode)
-        context.addIssue({
-            code: 'custom',
-            message: 'Compare either before/after sources or beforeManifest/afterManifest',
-        });
-    if (sourceMode && (value.before === undefined || value.after === undefined))
-        context.addIssue({ code: 'custom', message: 'Source comparison requires before and after' });
-    if (manifestMode && (value.beforeManifest === undefined || value.afterManifest === undefined))
-        context.addIssue({
-            code: 'custom',
-            message: 'Custom-pool comparison requires beforeManifest and afterManifest',
-        });
-    if (manifestMode && value.adapter !== undefined && value.adapter !== 'custom_weighted_pool')
-        context.addIssue({
-            code: 'custom',
-            path: ['adapter'],
-            message: 'Manifest comparison requires adapter custom_weighted_pool',
-        });
-});
-const renderInput = z
-    .object({
-    workspaceId: workspaceIdSchema,
-    analysisId: z.string().min(1).max(256),
-    expectedScenarioHash: sha256Schema.optional(),
-    outputs: z.array(probabilityOutputSchema).min(1).max(10),
-    includeHtml: z.boolean().default(false),
-    filter: nestedRenderFilter.optional(),
-})
-    .strict();
+import { strictOperationResultSchema } from '../server/result.js';
 const analysisDataSchema = z
     .object({
     operation: z.enum(['evaluate', 'sweep', 'simulate', 'sequence', 'compare', 'render']),
@@ -239,323 +72,66 @@ const readOnly = {
     idempotentHint: true,
     openWorldHint: false,
 };
-async function requestContext(engine, context, workspaceId, refresh, signal) {
-    return {
-        workspaceId: await resolveServerWorkspaceId(engine, context, workspaceId, signal),
-        ...(context.principal === undefined ? {} : { principal: context.principal }),
-        ...(refresh === undefined ? {} : { refresh }),
-        signal,
-    };
-}
-function analysisData(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,
-    };
-}
-function analysisServiceResult(workspaceId, result) {
-    const output = emptyServiceResult(workspaceId, analysisData(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 registerProbabilityTools(server, engine, context) {
-    const analyzer = new ProbabilityAnalyzer(engine);
-    const cacheLifetime = new IdleCacheLifetime(() => analyzer.clearCaches());
-    server.registerTool('hoi4.probability_inspect', {
+export const probabilityTaskTools = [
+    {
+        name: 'hoi4.probability_inspect',
         title: 'Inspect AI and MTTH weighted logic',
         description: 'Discover weighted adapters, candidates, provenance, and required inputs.',
-        inputSchema: inspectInput,
+        inputSchema: probabilityInspectRequestSchema,
         outputSchema: inspectOutput,
         annotations: readOnly,
-    }, async (input, extra) => {
-        const progress = progressReporter(extra);
-        const base = await requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            await progress.report(0, 2, 'Inspecting weighted source');
-            const inspected = await analyzer.inspect(base, input.adapter, input.source, input.candidatePool, input.customPoolManifest);
-            const result = emptyServiceResult(base.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);
-            await progress.report(2, 2, 'Weighted source inspection complete');
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, base.workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.probability_evaluate', {
+    },
+    {
+        name: 'hoi4.probability_evaluate',
         title: 'Evaluate AI and MTTH scenarios',
         description: 'Evaluate weights and probabilities under explicit scenarios.',
-        inputSchema: evaluateInput,
+        inputSchema: probabilityEvaluateRequestSchema,
         outputSchema: analysisOutput,
         annotations: readOnly,
-    }, async (input, extra) => {
-        const progress = progressReporter(extra);
-        const base = await requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            await progress.report(0, 3, 'Scanning and evaluating weighted source');
-            const request = {
-                ...base,
-                ...input,
-                workspaceId: base.workspaceId,
-            };
-            const analyzed = await analyzer.evaluate(request);
-            await progress.report(3, 3, 'Scenario evaluation complete');
-            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
-        }
-        catch (error) {
-            return errorResult(error, base.workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.probability_sweep', {
+    },
+    {
+        name: 'hoi4.probability_sweep',
         title: 'Sweep AI and MTTH parameters',
         description: 'Evaluate declared ranges, breakpoints, and rank reversals.',
-        inputSchema: sweepInput,
+        inputSchema: probabilitySweepRequestSchema,
         outputSchema: analysisOutput,
         annotations: readOnly,
-    }, async (input, extra) => {
-        const progress = progressReporter(extra);
-        const base = await requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            await progress.report(0, 3, 'Evaluating parameter sweep');
-            const request = {
-                ...base,
-                ...input,
-                workspaceId: base.workspaceId,
-            };
-            const analyzed = await analyzer.sweep(request);
-            await progress.report(3, 3, 'Parameter sweep complete');
-            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
-        }
-        catch (error) {
-            return errorResult(error, base.workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.probability_simulate', {
+    },
+    {
+        name: 'hoi4.probability_simulate',
         title: 'Simulate uncertain weighted scenarios',
         description: 'Run seeded simulations with distributions and confidence intervals.',
-        inputSchema: simulateInput,
+        inputSchema: probabilitySimulateRequestSchema,
         outputSchema: analysisOutput,
         annotations: readOnly,
-    }, async (input, extra) => {
-        const progress = progressReporter(extra);
-        const base = await requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            await progress.report(0, input.samples, 'Sampling uncertain scenarios');
-            const request = {
-                ...base,
-                ...input,
-                workspaceId: base.workspaceId,
-            };
-            const analyzed = await analyzer.simulate(request);
-            await progress.report(input.samples, input.samples, 'Seeded simulation complete');
-            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
-        }
-        catch (error) {
-            return errorResult(error, base.workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.probability_sequence', {
+    },
+    {
+        name: 'hoi4.probability_sequence',
         title: 'Analyze a declared weighted sequence',
         description: 'Analyze a manifest-declared dynamic weighted sequence.',
-        inputSchema: sequenceInput,
+        inputSchema: probabilitySequenceRequestSchema,
         outputSchema: analysisOutput,
         annotations: readOnly,
-    }, async (input, extra) => {
-        const progress = progressReporter(extra);
-        const base = await requestContext(engine, context, input.workspaceId, undefined, progress.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            await progress.report(0, input.maxSteps, 'Analyzing declared sequence');
-            const request = {
-                ...base,
-                ...input,
-                workspaceId: base.workspaceId,
-            };
-            const analyzed = await analyzer.sequence(request);
-            await progress.report(input.maxSteps, input.maxSteps, 'Sequence analysis complete');
-            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
-        }
-        catch (error) {
-            return errorResult(error, base.workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.probability_compare', {
+    },
+    {
+        name: 'hoi4.probability_compare',
         title: 'Compare weighted source patches',
         description: 'Compare sources or declared pools under identical scenarios.',
-        inputSchema: compareInput,
+        inputSchema: probabilityCompareRequestSchema,
         outputSchema: analysisOutput,
         annotations: readOnly,
-    }, async (input, extra) => {
-        const progress = progressReporter(extra);
-        const base = await requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            await progress.report(0, 4, 'Comparing weighted source');
-            const request = {
-                ...base,
-                ...input,
-                workspaceId: base.workspaceId,
-            };
-            const analyzed = await analyzer.compare(request);
-            await progress.report(4, 4, 'Weighted source comparison complete');
-            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
-        }
-        catch (error) {
-            return errorResult(error, base.workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.probability_render', {
+    },
+    {
+        name: 'hoi4.probability_render',
         title: 'Render AI and MTTH analysis',
-        description: 'Render cached probability analysis as deterministic resources.',
-        inputSchema: renderInput,
+        description: 'Render retained probability analysis as deterministic resources.',
+        inputSchema: probabilityRenderRequestSchema,
         outputSchema: analysisOutput,
         annotations: readOnly,
-    }, async (input, extra) => {
-        const progress = progressReporter(extra);
-        const base = await requestContext(engine, context, input.workspaceId, undefined, progress.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            await progress.report(0, input.outputs.length, 'Rendering analysis resources');
-            const request = {
-                ...base,
-                ...input,
-                workspaceId: base.workspaceId,
-                outputs: input.outputs.filter((output) => output !== 'json'),
-            };
-            const analyzed = await analyzer.render(request);
-            await progress.report(input.outputs.length, input.outputs.length, 'Analysis rendering complete');
-            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
-        }
-        catch (error) {
-            return errorResult(error, base.workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerPrompt('hoi4.probability_analysis', {
-        title: 'Analyze HOI4 weighted logic',
-        description: 'Plan one source-linked AI, MTTH, random, or declared-pool analysis and return to the owning modding workflow.',
-        argsSchema: {
-            objective: z.string().min(1).max(4096),
-            sourceHint: z.string().max(1024).optional(),
-        },
-    }, ({ objective, sourceHint }) => ({
-        messages: [
-            {
-                role: 'user',
-                content: {
-                    type: 'text',
-                    text: `Analyze this HOI4 weighted-logic task: ${objective}${sourceHint === undefined ? '' : `\nSource hint: ${sourceHint}`}\nIdentify the exact weighted surface and adapter, declare representative world-state scenarios and every required candidate or external factor, inspect first, run the narrowest useful evaluate/sweep/simulate/sequence/compare operation, review linked uncertainty and provenance, then return the findings to the normal owning modding workflow. Do not infer missing state, execute effects, or edit source through probability tools.`,
-                },
-            },
-        ],
-    }));
+    },
+];
+export function registerProbabilityTools(server) {
+    registerLegacyTaskTools(server, probabilityTaskTools);
+    const { name, ...metadata } = probabilityPromptDefinition;
+    server.registerPrompt(name, { ...metadata, argsSchema: probabilityPromptArguments.shape }, probabilityPrompt);
 }