@j0hanz/cortex-mcp 1.3.0 → 1.5.0

package/dist/resources/instructions.js

@@ -0,0 +1,103 @@
+import { getPromptContracts } from '../lib/prompt-contracts.js';
+import { getToolContracts } from '../lib/tool-contracts.js';
+import { getSharedConstraints } from './tool-info.js';
+function formatParam(p) {
+    const req = p.required ? 'required' : 'optional';
+    const desc = p.constraints
+        ? ` (${p.type}, ${req}; ${p.constraints})`
+        : ` (${p.type}, ${req})`;
+    return `- \`${p.name}\`${desc}`;
+}
+function formatPrompt(p) {
+    return `- \`${p.name}\`: ${p.description}`;
+}
+export function buildServerInstructions() {
+    const toolContracts = getToolContracts();
+    const promptContracts = getPromptContracts();
+    const toolSections = [...toolContracts]
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((c) => {
+        const params = c.params.map(formatParam).join('\n');
+        return `### \`${c.name}\`\n- Purpose: ${c.purpose}\n- Model: \`${c.model}\`\n- Parameters:\n${params}`;
+    });
+    const promptList = promptContracts
+        .filter((p) => p.name !== 'get-help')
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(formatPrompt)
+        .join('\n');
+    const sharedConstraints = getSharedConstraints()
+        .map((c) => `- ${c}`)
+        .join('\n');
+    return `# CORTEX-MCP INSTRUCTIONS
+
+These instructions are available as a resource (internal://instructions) or prompt (get-help). Load them when unsure about tool usage.
+
+---
+
+## CORE CAPABILITY
+
+- Domain: Multi-level reasoning engine that decomposes queries into structured thought chains at configurable depth levels (basic, normal, high).
+- Primary Resources: Reasoning sessions (in-memory, 30-minute TTL), thought chains, progress notifications.
+- Tools: \`reasoning_think\` (WRITE — creates/extends sessions with LLM-authored thoughts).
+
+---
+
+## PROMPTS
+
+- \`get-help\`: Returns these instructions for quick recall.
+${promptList}
+
+> **Guided templates:** Each \`reasoning.<level>\` prompt embeds a level-specific few-shot example showing the expected \`thought\` depth and step count. Only the template for the requested level is injected — the other two are omitted to keep prompts lean.
+
+---
+
+## RESOURCES & RESOURCE LINKS
+
+- \`internal://instructions\`: This document.
+- \`reasoning://sessions\`: List all active reasoning sessions with metadata (JSON).
+- \`reasoning://sessions/{sessionId}\`: Inspect a specific session's thoughts and metadata (JSON). Supports auto-completion on \`sessionId\`.
+- \`file:///cortex/sessions/{sessionId}/trace.md\`: Full Markdown trace of a session. Supports auto-completion on \`sessionId\`.
+- \`file:///cortex/sessions/{sessionId}/{thoughtName}.md\`: Markdown content of a single thought (e.g., \`Thought-1.md\`). Supports auto-completion on \`sessionId\` and \`thoughtName\`.
+- The server supports \`resources/subscribe\` for real-time change notifications on individual resources.
+- Subscribe to \`reasoning://sessions/{sessionId}\` to receive \`notifications/resources/updated\` when thoughts are added, revised, or status changes.
+- Subscribe to \`reasoning://sessions\` to receive aggregate updates as session content and statuses evolve.
+- Use subscriptions to monitor session progress without polling.
+
+---
+
+## PROGRESS & TASKS
+
+- Include \`_meta.progressToken\` in requests to receive \`notifications/progress\` updates during reasoning.
+- Task-augmented tool calls are supported for \`reasoning_think\`:
+  - \`execution.taskSupport: "optional"\` — invoke normally or as a task.
+  - Send \`tools/call\` with \`task\` to get a task id.
+  - Poll \`tasks/get\` and fetch results via \`tasks/result\`.
+  - Use \`tasks/cancel\` to abort a running task.
+  - For \`high\` level, progress is emitted every 2 steps to reduce noise; \`basic\` and \`normal\` emit after every step.
+  - Use \`runMode: "run_to_completion"\` with \`thought\` + \`thoughts[]\` to execute multiple reasoning steps in one request.
+
+---
+
+## TOOL CONTRACTS
+
+${toolSections.join('\n\n')}
+
+---
+
+## SHARED CONSTRAINTS
+
+${sharedConstraints}
+
+---
+
+## ERROR HANDLING STRATEGY
+
+- \`E_SESSION_NOT_FOUND\`: Session expired or never existed. Call \`reasoning://sessions\` to list active sessions, or start a new session without \`sessionId\`.
+- \`E_INVALID_THOUGHT_COUNT\`: \`targetThoughts\` is outside the level range. Check ranges: basic (3–5), normal (6–10), high (15–25).
+- \`E_INSUFFICIENT_THOUGHTS\`: In \`run_to_completion\`, the request did not provide enough thought inputs for planned remaining steps.
+- \`E_INVALID_RUN_MODE_ARGS\`: Invalid \`runMode\` argument combination (for example, missing \`targetThoughts\` when starting a new run-to-completion session).
+- \`E_ABORTED\`: Reasoning was cancelled via abort signal or task cancellation. Retry with a new request if needed.
+- \`E_SERVER_BUSY\`: Too many concurrent task-mode reasoning calls (default cap: 32). Retry after a short delay, or use normal (non-task) invocation.
+- \`E_REASONING\`: Unexpected engine error. Check the error \`message\` field for details and retry.
+`;
+}

package/dist/resources/tool-catalog.d.ts

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

package/dist/resources/tool-catalog.js

@@ -0,0 +1,20 @@
+import { buildCoreContextPack } from './tool-info.js';
+const CATALOG_GUIDE = `# Tool Catalog Details
+## Optional Parameters
+- \`observation\`: What facts are known at this step? Use with \`hypothesis\` and \`evaluation\` as an alternative to \`thought\`.
+- \`hypothesis\`: What is the proposed idea or next logical leap?
+- \`evaluation\`: Critique the hypothesis. Are there flaws?
+- \`step_summary\`: A 1-sentence summary of the conclusion reached in this step. Accumulates in the \`summary\` field for contextual guidance.
+- \`is_conclusion\`: Set to true to end the session early with a final answer.
+- \`rollback_to_step\`: Roll back to a thought index (0-based). All thoughts after this index are discarded.
+
+## Cross-Tool Data Flow
+\`\`\`
+reasoning_think -> result.sessionId -> reasoning_think.sessionId
+reasoning_think -> result.sessionId -> reasoning://sessions/{sessionId}
+reasoning_think -> result.sessionId -> file:///cortex/sessions/{sessionId}/trace.md
+\`\`\`
+`;
+export function buildToolCatalog() {
+    return `${buildCoreContextPack()}\n\n${CATALOG_GUIDE}`;
+}

package/dist/resources/tool-info.d.ts

@@ -0,0 +1,2 @@
+export declare function buildCoreContextPack(): string;
+export declare function getSharedConstraints(): string[];

package/dist/resources/tool-info.js

@@ -0,0 +1,35 @@
+import { getToolContracts } from '../lib/tool-contracts.js';
+function toEntry(contract) {
+    return {
+        name: contract.name,
+        model: contract.model,
+        timeout: contract.timeoutMs > 0
+            ? `${Math.round(contract.timeoutMs / 1_000)}s`
+            : 'N/A',
+        maxOutputTokens: contract.maxOutputTokens > 0 ? String(contract.maxOutputTokens) : 'N/A',
+        purpose: contract.purpose,
+    };
+}
+const ENTRIES = Object.fromEntries(getToolContracts().map((contract) => [contract.name, toEntry(contract)]));
+export function buildCoreContextPack() {
+    const names = Object.keys(ENTRIES).sort((a, b) => a.localeCompare(b));
+    const rows = names.map((name) => {
+        const e = ENTRIES[name];
+        return e
+            ? `| \`${e.name}\` | ${e.model} | ${e.timeout} | ${e.maxOutputTokens} | ${e.purpose} |`
+            : '';
+    });
+    return `# Core Context Pack\n\n| Tool | Model | Timeout | Max Output Tokens | Purpose |\n|------|-------|---------|-------------------|---------|\n${rows.join('\n')}`;
+}
+export function getSharedConstraints() {
+    return [
+        'Sessions are in-memory — all data is lost on process restart.',
+        'Session TTL: 30 minutes from last update. Expired sessions cannot be recovered.',
+        'Maximum query length: 10,000 characters.',
+        'Token budget enforcement is approximate (character-based proxy, not true tokenization).',
+        'stdio transport only — no HTTP endpoint available.',
+        'Every thought in the trace contains LLM-authored reasoning content provided via the `thought` parameter.',
+        "targetThoughts must be an integer within the level's min/max range.",
+        'Session store limits are configurable via CORTEX_SESSION_TTL_MS, CORTEX_MAX_SESSIONS, and CORTEX_MAX_TOTAL_TOKENS.',
+    ];
+}

package/dist/resources/workflows.d.ts

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

package/dist/resources/workflows.js

@@ -0,0 +1,61 @@
+import { getToolContracts } from '../lib/tool-contracts.js';
+import { getSharedConstraints } from './tool-info.js';
+function buildToolReference() {
+    return [...getToolContracts()]
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((c) => `### \`${c.name}\`\n- Purpose: ${c.purpose}\n- Output: \`${c.outputShape}\``)
+        .join('\n\n');
+}
+export function buildWorkflowGuide() {
+    return `# THE "GOLDEN PATH" WORKFLOWS (CRITICAL)
+
+### WORKFLOW A: Sequential Reasoning (Most Common)
+
+1. Call \`reasoning_think\` with \`{ query: "...", level: "basic", thought: "Your detailed reasoning for step 1..." }\`.
+2. Read the response — note the \`sessionId\` and \`remainingThoughts\` fields.
+3. **You MUST continue**: Call again with \`{ sessionId: "<from response>", thought: "Your next reasoning step..." }\`.
+4. Repeat step 3 until the response shows \`status: "completed"\` or \`remainingThoughts: 0\`.
+   NOTE: The \`summary\` field contains the exact continuation call you should make next.
+
+### WORKFLOW B: Multi-Turn Reasoning (Session Continuation)
+
+1. Call \`reasoning_think\` with \`{ query: "initial question", level: "normal", thought: "Your first reasoning step..." }\` — note the returned \`sessionId\`.
+2. Call \`reasoning_think\` with \`{ sessionId: "<id>", thought: "Your next reasoning step..." }\` (optional: add \`query\` for follow-up context).
+3. Repeat until \`status: "completed"\` or \`remainingThoughts: 0\`, then read \`reasoning://sessions/{sessionId}\` for the full chain.
+   NOTE: The \`level\` parameter is optional when continuing; if provided and mismatched, the session level is used.
+
+### WORKFLOW C: Controlled Depth Reasoning
+
+1. Call \`reasoning_think\` with \`{ query: "...", level: "normal", targetThoughts: 8, thought: "Your reasoning..." }\` to set the session's planned step count.
+2. Repeat calls with the returned \`sessionId\` and your next \`thought\` until \`result.totalThoughts\` is reached.
+   NOTE: \`targetThoughts\` must fall within the level range (basic: 3–5, normal: 6–10, high: 15–25). Out-of-range values return \`E_INVALID_THOUGHT_COUNT\`.
+
+### WORKFLOW D: Async Task Execution
+
+1. Call \`reasoning_think\` as a task (send \`tools/call\` with \`task\` field) for long-running \`high\`-level reasoning.
+2. Poll \`tasks/get\` until status is \`completed\` or \`failed\`.
+3. Retrieve the result via \`tasks/result\`.
+4. Use \`tasks/cancel\` to abort if needed.
+
+### WORKFLOW E: Batched Run-To-Completion
+
+1. Start a new session with explicit \`targetThoughts\` and \`runMode: "run_to_completion"\`.
+2. Provide one \`thought\` plus additional \`thoughts[]\` entries to cover the planned step count.
+3. The server consumes thought inputs in order until completion, token budget exhaustion, or cancellation.
+
+### WORKFLOW F: Structured Reasoning (Observation/Hypothesis/Evaluation)
+
+1. Call \`reasoning_think\` with \`{ query: "...", level: "normal", observation: "facts...", hypothesis: "idea...", evaluation: "critique..." }\`.
+2. The server formats these into a structured thought and stores it in the session trace.
+3. Continue with \`sessionId\` using either \`thought\` or structured fields for subsequent steps.
+4. Use \`is_conclusion: true\` to end early, or \`rollback_to_step\` to discard and redo from a specific step.
+
+## Shared Constraints
+${getSharedConstraints()
+        .map((c) => `- ${c}`)
+        .join('\n')}
+
+## Tool Reference
+${buildToolReference()}
+`;
+}

package/dist/schemas/inputs.d.ts

@@ -12,8 +12,13 @@ export declare const ReasoningThinkInputSchema: z.ZodObject<{
         step: "step";
         run_to_completion: "run_to_completion";
     }>>;
-    thought: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    thought: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     thoughts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    is_conclusion: z.ZodOptional<z.ZodBoolean>;
+    rollback_to_step: z.ZodOptional<z.ZodNumber>;
+    step_summary: z.ZodOptional<z.ZodString>;
+    observation: z.ZodOptional<z.ZodString>;
+    hypothesis: z.ZodOptional<z.ZodString>;
+    evaluation: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type ReasoningThinkInput = z.infer<typeof ReasoningThinkInputSchema>;
-//# sourceMappingURL=inputs.d.ts.map

package/dist/schemas/inputs.js

@@ -1,10 +1,11 @@
 import { z } from 'zod';
+import { getLevelDescriptionString } from '../engine/config.js';
+import { REASONING_LEVELS } from '../lib/types.js';
 import { getTargetThoughtsError } from '../lib/validators.js';
 const RUN_MODE_VALUES = ['step', 'run_to_completion'];
 const DEFAULT_RUN_MODE = 'step';
-const LEVEL_VALUES = ['basic', 'normal', 'high'];
+const LEVEL_SCHEMA = z.enum(REASONING_LEVELS);
 const QUERY_TEXT_SCHEMA = z.string().min(1).max(10000);
-const LEVEL_SCHEMA = z.enum(LEVEL_VALUES);
 const THOUGHT_TEXT_SCHEMA = z.string().min(1).max(100000);
 const THOUGHT_BATCH_SCHEMA = z.array(THOUGHT_TEXT_SCHEMA).min(1).max(25);
 function addCustomIssue(ctx, path, message) {
@@ -17,11 +18,12 @@ function addCustomIssue(ctx, path, message) {
 export const ReasoningThinkInputSchema = z
     .strictObject({
     query: QUERY_TEXT_SCHEMA.optional().describe('The question or problem to reason about'),
-    level: LEVEL_SCHEMA.optional().describe('Reasoning depth level (required for new sessions, optional for continuing)'),
+    level: LEVEL_SCHEMA.optional().describe(`Reasoning depth level (required for new sessions, optional for continuing). ${getLevelDescriptionString()}.`),
     targetThoughts: z
         .number()
         .int()
         .min(1)
+        .max(25)
         .optional()
         .describe('Optional explicit thought count. Must fit the level range: basic 3–5, normal 6–10, high 15–25.'),
     sessionId: z
@@ -36,6 +38,7 @@ export const ReasoningThinkInputSchema = z
         .describe('Execution mode (default: "step"). "step" appends a single thought per call. "run_to_completion" consumes all supplied thought inputs in one request.'),
     thought: z
         .union([THOUGHT_TEXT_SCHEMA, THOUGHT_BATCH_SCHEMA])
+        .optional()
         .describe('Your full reasoning content for this step. ' +
         'The server stores this text verbatim as the thought in the session trace. ' +
         'Write your complete analysis, observations, and conclusions here — this is what appears in trace.md. ' +
@@ -45,6 +48,32 @@ export const ReasoningThinkInputSchema = z
         .max(25)
         .optional()
         .describe('(Deprecated) Optional additional thought inputs. Use "thought" as an array instead.'),
+    is_conclusion: z
+        .boolean()
+        .optional()
+        .describe('Set to true if you have arrived at the final answer and wish to end the reasoning session early.'),
+    rollback_to_step: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe('Set to a thought index (0-based) to rollback to. All thoughts after this index will be discarded.'),
+    step_summary: z
+        .string()
+        .optional()
+        .describe('A 1-sentence summary of the conclusion reached in this specific step.'),
+    observation: z
+        .string()
+        .optional()
+        .describe('What facts are known at this step?'),
+    hypothesis: z
+        .string()
+        .optional()
+        .describe('What is the proposed idea or next logical leap?'),
+    evaluation: z
+        .string()
+        .optional()
+        .describe('Critique the hypothesis. Are there flaws?'),
 })
     .superRefine((data, ctx) => {
     const runMode = data.runMode ?? DEFAULT_RUN_MODE;
@@ -65,6 +94,13 @@ export const ReasoningThinkInputSchema = z
     if (runMode === 'step' && data.thoughts !== undefined) {
         addCustomIssue(ctx, ['thoughts'], 'thoughts is only allowed when runMode is "run_to_completion"');
     }
+    const hasThought = data.thought !== undefined;
+    const hasStructured = data.observation !== undefined &&
+        data.hypothesis !== undefined &&
+        data.evaluation !== undefined;
+    if (!hasThought && !hasStructured && data.rollback_to_step === undefined) {
+        addCustomIssue(ctx, ['thought'], 'Either "thought" or structured fields ("observation", "hypothesis", "evaluation") are required, unless rolling back.');
+    }
     if (data.targetThoughts === undefined || data.level === undefined) {
         return;
     }
@@ -73,4 +109,3 @@ export const ReasoningThinkInputSchema = z
         addCustomIssue(ctx, ['targetThoughts'], error);
     }
 });
-//# sourceMappingURL=inputs.js.map

package/dist/schemas/outputs.d.ts

@@ -1,12 +1,4 @@
 import { z } from 'zod';
-export declare const DefaultOutputSchema: z.ZodObject<{
-    ok: z.ZodBoolean;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodObject<{
-        code: z.ZodString;
-        message: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
 declare const ReasoningThinkSuccessSchema: z.ZodObject<{
     ok: z.ZodLiteral<true>;
     result: z.ZodObject<{
@@ -25,6 +17,7 @@ declare const ReasoningThinkSuccessSchema: z.ZodObject<{
             index: z.ZodNumber;
             content: z.ZodString;
             revision: z.ZodNumber;
+            stepSummary: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         generatedThoughts: z.ZodNumber;
         requestedThoughts: z.ZodNumber;
@@ -39,9 +32,13 @@ declare const ReasoningThinkSuccessSchema: z.ZodObject<{
         summary: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export declare const ReasoningThinkResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    ok: z.ZodLiteral<true>;
-    result: z.ZodObject<{
+/**
+ * Tool-facing output schema kept as a strict object so SDK tooling
+ * can advertise outputSchema via tools/list.
+ */
+export declare const ReasoningThinkToolOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    result: z.ZodOptional<z.ZodObject<{
         sessionId: z.ZodString;
         level: z.ZodEnum<{
             basic: "basic";
@@ -57,6 +54,7 @@ export declare const ReasoningThinkResultSchema: z.ZodDiscriminatedUnion<[z.ZodO
             index: z.ZodNumber;
             content: z.ZodString;
             revision: z.ZodNumber;
+            stepSummary: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         generatedThoughts: z.ZodNumber;
         requestedThoughts: z.ZodNumber;
@@ -69,21 +67,28 @@ export declare const ReasoningThinkResultSchema: z.ZodDiscriminatedUnion<[z.ZodO
         updatedAt: z.ZodNumber;
         remainingThoughts: z.ZodNumber;
         summary: z.ZodString;
-    }, z.core.$strict>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReasoningThinkSuccess = z.infer<typeof ReasoningThinkSuccessSchema>;
+/** Generic ok/error envelope — useful for contract tests and external validators. */
+export declare const DefaultOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    result: z.ZodUnknown;
 }, z.core.$strict>, z.ZodObject<{
     ok: z.ZodLiteral<false>;
     error: z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
     }, z.core.$strict>;
-}, z.core.$strict>], "ok">;
-/**
- * Tool-facing output schema kept as a strict object so SDK tooling
- * can advertise outputSchema via tools/list.
- */
-export declare const ReasoningThinkToolOutputSchema: z.ZodObject<{
-    ok: z.ZodBoolean;
-    result: z.ZodOptional<z.ZodObject<{
+}, z.core.$strict>]>;
+/** Full discriminated union for the reasoning_think tool result. */
+export declare const ReasoningThinkResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    result: z.ZodObject<{
         sessionId: z.ZodString;
         level: z.ZodEnum<{
             basic: "basic";
@@ -99,6 +104,7 @@ export declare const ReasoningThinkToolOutputSchema: z.ZodObject<{
             index: z.ZodNumber;
             content: z.ZodString;
             revision: z.ZodNumber;
+            stepSummary: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         generatedThoughts: z.ZodNumber;
         requestedThoughts: z.ZodNumber;
@@ -111,12 +117,12 @@ export declare const ReasoningThinkToolOutputSchema: z.ZodObject<{
         updatedAt: z.ZodNumber;
         remainingThoughts: z.ZodNumber;
         summary: z.ZodString;
-    }, z.core.$strict>>;
-    error: z.ZodOptional<z.ZodObject<{
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ReasoningThinkSuccess = z.infer<typeof ReasoningThinkSuccessSchema>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
 export {};
-//# sourceMappingURL=outputs.d.ts.map

package/dist/schemas/outputs.js

@@ -1,28 +1,26 @@
 import { z } from 'zod';
+import { REASONING_LEVELS, SESSION_STATUSES } from '../lib/types.js';
 const ErrorInfoSchema = z.strictObject({
     code: z.string(),
     message: z.string(),
 });
 const MISSING_RESULT_PATH = ['result'];
 const MISSING_ERROR_PATH = ['error'];
-const LEVEL_VALUES = ['basic', 'normal', 'high'];
-const STATUS_VALUES = ['active', 'completed', 'cancelled'];
 const ThoughtSchema = z.strictObject({
     index: z.number(),
     content: z.string(),
     revision: z.number(),
-});
-export const DefaultOutputSchema = z.strictObject({
-    ok: z.boolean(),
-    result: z.unknown().optional(),
-    error: ErrorInfoSchema.optional(),
+    stepSummary: z
+        .string()
+        .optional()
+        .describe('A 1-sentence summary of the conclusion reached in this step, if provided.'),
 });
 const ReasoningThinkSuccessSchema = z.strictObject({
     ok: z.literal(true),
     result: z.strictObject({
         sessionId: z.string(),
-        level: z.enum(LEVEL_VALUES),
-        status: z.enum(STATUS_VALUES),
+        level: z.enum(REASONING_LEVELS),
+        status: z.enum(SESSION_STATUSES),
         thoughts: z.array(ThoughtSchema),
         generatedThoughts: z.number(),
         requestedThoughts: z.number(),
@@ -49,10 +47,6 @@ const ReasoningThinkErrorSchema = z.strictObject({
     ok: z.literal(false),
     error: ErrorInfoSchema,
 });
-export const ReasoningThinkResultSchema = z.discriminatedUnion('ok', [
-    ReasoningThinkSuccessSchema,
-    ReasoningThinkErrorSchema,
-]);
 function getMissingFieldIssue(data) {
     if (data.ok && data.result === undefined) {
         return {
@@ -88,4 +82,13 @@ export const ReasoningThinkToolOutputSchema = z
         });
     }
 });
-//# sourceMappingURL=outputs.js.map
+/** Generic ok/error envelope — useful for contract tests and external validators. */
+export const DefaultOutputSchema = z.union([
+    z.strictObject({ ok: z.literal(true), result: z.unknown() }),
+    z.strictObject({ ok: z.literal(false), error: ErrorInfoSchema }),
+]);
+/** Full discriminated union for the reasoning_think tool result. */
+export const ReasoningThinkResultSchema = z.union([
+    ReasoningThinkSuccessSchema,
+    ReasoningThinkErrorSchema,
+]);

package/dist/server.d.ts

@@ -1,3 +1,2 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function createServer(): McpServer;
-//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -4,7 +4,6 @@ import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { engineEvents } from './engine/events.js';
 import { getErrorMessage } from './lib/errors.js';
-import { loadInstructions } from './lib/instructions.js';
 import { registerAllTools } from './tools/index.js';
 import { registerAllPrompts } from './prompts/index.js';
 import { registerAllResources } from './resources/index.js';
@@ -147,7 +146,6 @@ function installCloseCleanup(server, cleanup) {
     };
 }
 export function createServer() {
-    const instructions = loadInstructions();
     const version = loadVersion();
     const taskStore = new InMemoryTaskStore();
     const localIcon = getLocalIconData();
@@ -180,7 +178,7 @@ export function createServer() {
             },
         },
         taskStore,
-        ...(instructions ? { instructions } : {}),
+        instructions: 'Multi-level reasoning MCP server. Use reasoning_think to decompose queries into sequential thought steps at basic (3–5), normal (6–10), or high (15–25) depth. Full usage guide: read internal://instructions or invoke get-help.',
     });
     registerAllTools(server, iconMeta);
     registerAllPrompts(server, iconMeta);
@@ -189,4 +187,3 @@ export function createServer() {
     installCloseCleanup(server, detachEngineHandlers);
     return server;
 }
-//# sourceMappingURL=server.js.map

package/dist/tools/index.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { IconMeta } from '../lib/types.js';
 export declare function registerAllTools(server: McpServer, iconMeta?: IconMeta): void;
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -5,4 +5,3 @@ export function registerAllTools(server, iconMeta) {
         registerTool(server, iconMeta);
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/tools/reasoning-think.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { IconMeta } from '../lib/types.js';
 export declare function registerReasoningThinkTool(server: McpServer, iconMeta?: IconMeta): void;
-//# sourceMappingURL=reasoning-think.d.ts.map