deepthinking-mcp 4.3.2 → 4.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.js +572 -571
  2. package/dist/index.js.map +1 -1
  3. package/package.json +3 -2
package/dist/index.js CHANGED
@@ -1,13 +1,14 @@
1
1
  #!/usr/bin/env node
2
2
  import { dirname, join } from 'path';
3
3
  import { fileURLToPath } from 'url';
4
- import { z } from 'zod';
4
+ import { z as z$1 } from 'zod/v3';
5
5
  import { zodToJsonSchema } from 'zod-to-json-schema';
6
6
  import { createHash, randomUUID } from 'crypto';
7
7
  import { Server } from '@modelcontextprotocol/sdk/server/index.js';
8
8
  import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
9
9
  import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
10
10
  import { readFileSync } from 'fs';
11
+ import { z } from 'zod';
11
12
 
12
13
  var __defProp = Object.defineProperty;
13
14
  var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -33,691 +34,691 @@ var ThinkingToolSchema, generateMcpSchema, thinkingTool;
33
34
  var init_thinking = __esm({
34
35
  "src/tools/thinking.ts"() {
35
36
  init_esm_shims();
36
- ThinkingToolSchema = z.object({
37
- sessionId: z.string().optional(),
38
- mode: z.enum(["sequential", "shannon", "mathematics", "physics", "hybrid", "abductive", "causal", "bayesian", "counterfactual", "analogical", "temporal", "gametheory", "evidential", "firstprinciples", "systemsthinking", "scientificmethod", "optimization", "formallogic"]).default("hybrid"),
39
- thought: z.string(),
40
- thoughtNumber: z.number().int().positive(),
41
- totalThoughts: z.number().int().positive(),
42
- nextThoughtNeeded: z.boolean(),
43
- isRevision: z.boolean().optional(),
44
- revisesThought: z.string().optional(),
45
- revisionReason: z.string().optional(),
46
- branchFrom: z.string().optional(),
47
- branchId: z.string().optional(),
48
- stage: z.enum(["problem_definition", "constraints", "model", "proof", "implementation"]).optional(),
49
- uncertainty: z.number().min(0).max(1).optional(),
50
- dependencies: z.array(z.string()).optional(),
51
- assumptions: z.array(z.string()).optional(),
52
- thoughtType: z.string().optional(),
53
- mathematicalModel: z.object({
54
- latex: z.string(),
55
- symbolic: z.string(),
56
- ascii: z.string().optional()
37
+ ThinkingToolSchema = z$1.object({
38
+ sessionId: z$1.string().optional(),
39
+ mode: z$1.enum(["sequential", "shannon", "mathematics", "physics", "hybrid", "abductive", "causal", "bayesian", "counterfactual", "analogical", "temporal", "gametheory", "evidential", "firstprinciples", "systemsthinking", "scientificmethod", "optimization", "formallogic"]).default("hybrid"),
40
+ thought: z$1.string(),
41
+ thoughtNumber: z$1.number().int().positive(),
42
+ totalThoughts: z$1.number().int().positive(),
43
+ nextThoughtNeeded: z$1.boolean(),
44
+ isRevision: z$1.boolean().optional(),
45
+ revisesThought: z$1.string().optional(),
46
+ revisionReason: z$1.string().optional(),
47
+ branchFrom: z$1.string().optional(),
48
+ branchId: z$1.string().optional(),
49
+ stage: z$1.enum(["problem_definition", "constraints", "model", "proof", "implementation"]).optional(),
50
+ uncertainty: z$1.number().min(0).max(1).optional(),
51
+ dependencies: z$1.array(z$1.string()).optional(),
52
+ assumptions: z$1.array(z$1.string()).optional(),
53
+ thoughtType: z$1.string().optional(),
54
+ mathematicalModel: z$1.object({
55
+ latex: z$1.string(),
56
+ symbolic: z$1.string(),
57
+ ascii: z$1.string().optional()
57
58
  }).optional(),
58
- proofStrategy: z.object({
59
- type: z.enum(["direct", "contradiction", "induction", "construction", "contrapositive"]),
60
- steps: z.array(z.string())
59
+ proofStrategy: z$1.object({
60
+ type: z$1.enum(["direct", "contradiction", "induction", "construction", "contrapositive"]),
61
+ steps: z$1.array(z$1.string())
61
62
  }).optional(),
62
- tensorProperties: z.object({
63
- rank: z.tuple([z.number(), z.number()]),
64
- components: z.string(),
65
- latex: z.string(),
66
- symmetries: z.array(z.string()),
67
- invariants: z.array(z.string()),
68
- transformation: z.enum(["covariant", "contravariant", "mixed"])
63
+ tensorProperties: z$1.object({
64
+ rank: z$1.tuple([z$1.number(), z$1.number()]),
65
+ components: z$1.string(),
66
+ latex: z$1.string(),
67
+ symmetries: z$1.array(z$1.string()),
68
+ invariants: z$1.array(z$1.string()),
69
+ transformation: z$1.enum(["covariant", "contravariant", "mixed"])
69
70
  }).optional(),
70
- physicalInterpretation: z.object({
71
- quantity: z.string(),
72
- units: z.string(),
73
- conservationLaws: z.array(z.string())
71
+ physicalInterpretation: z$1.object({
72
+ quantity: z$1.string(),
73
+ units: z$1.string(),
74
+ conservationLaws: z$1.array(z$1.string())
74
75
  }).optional(),
75
76
  // Abductive reasoning properties (v2.0)
76
- observations: z.array(z.object({
77
- id: z.string(),
78
- description: z.string(),
79
- confidence: z.number().min(0).max(1)
77
+ observations: z$1.array(z$1.object({
78
+ id: z$1.string(),
79
+ description: z$1.string(),
80
+ confidence: z$1.number().min(0).max(1)
80
81
  })).optional(),
81
- hypotheses: z.array(z.object({
82
- id: z.string(),
82
+ hypotheses: z$1.array(z$1.object({
83
+ id: z$1.string(),
83
84
  // Abductive fields
84
- explanation: z.string().optional(),
85
- assumptions: z.array(z.string()).optional(),
86
- predictions: z.array(z.string()).optional(),
87
- score: z.number().optional(),
85
+ explanation: z$1.string().optional(),
86
+ assumptions: z$1.array(z$1.string()).optional(),
87
+ predictions: z$1.array(z$1.string()).optional(),
88
+ score: z$1.number().optional(),
88
89
  // Evidential fields
89
- name: z.string().optional(),
90
- description: z.string().optional(),
91
- mutuallyExclusive: z.boolean().optional(),
92
- subsets: z.array(z.string()).optional()
90
+ name: z$1.string().optional(),
91
+ description: z$1.string().optional(),
92
+ mutuallyExclusive: z$1.boolean().optional(),
93
+ subsets: z$1.array(z$1.string()).optional()
93
94
  })).optional(),
94
- evaluationCriteria: z.object({
95
- parsimony: z.number(),
96
- explanatoryPower: z.number(),
97
- plausibility: z.number(),
98
- testability: z.boolean()
95
+ evaluationCriteria: z$1.object({
96
+ parsimony: z$1.number(),
97
+ explanatoryPower: z$1.number(),
98
+ plausibility: z$1.number(),
99
+ testability: z$1.boolean()
99
100
  }).optional(),
100
- evidence: z.array(z.object({
101
- id: z.string(),
102
- description: z.string(),
101
+ evidence: z$1.array(z$1.object({
102
+ id: z$1.string(),
103
+ description: z$1.string(),
103
104
  // Abductive fields
104
- hypothesisId: z.string().optional(),
105
- type: z.enum(["supporting", "contradicting", "neutral"]).optional(),
106
- strength: z.number().min(0).max(1).optional(),
105
+ hypothesisId: z$1.string().optional(),
106
+ type: z$1.enum(["supporting", "contradicting", "neutral"]).optional(),
107
+ strength: z$1.number().min(0).max(1).optional(),
107
108
  // Evidential fields
108
- source: z.string().optional(),
109
- reliability: z.number().min(0).max(1).optional(),
110
- timestamp: z.number().optional(),
111
- supports: z.array(z.string()).optional(),
112
- contradicts: z.array(z.string()).optional()
109
+ source: z$1.string().optional(),
110
+ reliability: z$1.number().min(0).max(1).optional(),
111
+ timestamp: z$1.number().optional(),
112
+ supports: z$1.array(z$1.string()).optional(),
113
+ contradicts: z$1.array(z$1.string()).optional()
113
114
  })).optional(),
114
- bestExplanation: z.object({
115
- id: z.string(),
116
- explanation: z.string(),
117
- assumptions: z.array(z.string()),
118
- predictions: z.array(z.string()),
119
- score: z.number()
115
+ bestExplanation: z$1.object({
116
+ id: z$1.string(),
117
+ explanation: z$1.string(),
118
+ assumptions: z$1.array(z$1.string()),
119
+ predictions: z$1.array(z$1.string()),
120
+ score: z$1.number()
120
121
  }).optional(),
121
122
  // Causal reasoning properties (v2.0)
122
- causalGraph: z.object({
123
- nodes: z.array(z.object({
124
- id: z.string(),
125
- name: z.string(),
126
- type: z.enum(["cause", "effect", "mediator", "confounder"]),
127
- description: z.string()
123
+ causalGraph: z$1.object({
124
+ nodes: z$1.array(z$1.object({
125
+ id: z$1.string(),
126
+ name: z$1.string(),
127
+ type: z$1.enum(["cause", "effect", "mediator", "confounder"]),
128
+ description: z$1.string()
128
129
  })),
129
- edges: z.array(z.object({
130
- from: z.string(),
131
- to: z.string(),
132
- strength: z.number(),
133
- confidence: z.number().min(0).max(1)
130
+ edges: z$1.array(z$1.object({
131
+ from: z$1.string(),
132
+ to: z$1.string(),
133
+ strength: z$1.number(),
134
+ confidence: z$1.number().min(0).max(1)
134
135
  }))
135
136
  }).optional(),
136
- interventions: z.array(z.object({
137
- nodeId: z.string(),
138
- action: z.string(),
139
- expectedEffects: z.array(z.object({
140
- nodeId: z.string(),
141
- expectedChange: z.string(),
142
- confidence: z.number()
137
+ interventions: z$1.array(z$1.object({
138
+ nodeId: z$1.string(),
139
+ action: z$1.string(),
140
+ expectedEffects: z$1.array(z$1.object({
141
+ nodeId: z$1.string(),
142
+ expectedChange: z$1.string(),
143
+ confidence: z$1.number()
143
144
  }))
144
145
  })).optional(),
145
- mechanisms: z.array(z.object({
146
- from: z.string(),
147
- to: z.string(),
148
- description: z.string(),
149
- type: z.enum(["direct", "indirect", "feedback"])
146
+ mechanisms: z$1.array(z$1.object({
147
+ from: z$1.string(),
148
+ to: z$1.string(),
149
+ description: z$1.string(),
150
+ type: z$1.enum(["direct", "indirect", "feedback"])
150
151
  })).optional(),
151
- confounders: z.array(z.object({
152
- nodeId: z.string(),
153
- affects: z.array(z.string()),
154
- description: z.string()
152
+ confounders: z$1.array(z$1.object({
153
+ nodeId: z$1.string(),
154
+ affects: z$1.array(z$1.string()),
155
+ description: z$1.string()
155
156
  })).optional(),
156
157
  // Bayesian reasoning properties (v2.0)
157
- hypothesis: z.object({
158
- id: z.string(),
159
- statement: z.string()
158
+ hypothesis: z$1.object({
159
+ id: z$1.string(),
160
+ statement: z$1.string()
160
161
  }).optional(),
161
- prior: z.object({
162
- probability: z.number().min(0).max(1),
163
- justification: z.string()
162
+ prior: z$1.object({
163
+ probability: z$1.number().min(0).max(1),
164
+ justification: z$1.string()
164
165
  }).optional(),
165
- likelihood: z.object({
166
- probability: z.number().min(0).max(1),
167
- description: z.string()
166
+ likelihood: z$1.object({
167
+ probability: z$1.number().min(0).max(1),
168
+ description: z$1.string()
168
169
  }).optional(),
169
- posterior: z.object({
170
- probability: z.number().min(0).max(1),
171
- calculation: z.string()
170
+ posterior: z$1.object({
171
+ probability: z$1.number().min(0).max(1),
172
+ calculation: z$1.string()
172
173
  }).optional(),
173
- bayesFactor: z.number().optional(),
174
+ bayesFactor: z$1.number().optional(),
174
175
  // Counterfactual reasoning properties (v2.0)
175
- actual: z.object({
176
- id: z.string(),
177
- name: z.string(),
178
- description: z.string(),
179
- conditions: z.array(z.object({
180
- factor: z.string(),
181
- value: z.string()
176
+ actual: z$1.object({
177
+ id: z$1.string(),
178
+ name: z$1.string(),
179
+ description: z$1.string(),
180
+ conditions: z$1.array(z$1.object({
181
+ factor: z$1.string(),
182
+ value: z$1.string()
182
183
  })),
183
- outcomes: z.array(z.object({
184
- description: z.string(),
185
- impact: z.enum(["positive", "negative", "neutral"]),
186
- magnitude: z.number().optional()
184
+ outcomes: z$1.array(z$1.object({
185
+ description: z$1.string(),
186
+ impact: z$1.enum(["positive", "negative", "neutral"]),
187
+ magnitude: z$1.number().optional()
187
188
  }))
188
189
  }).optional(),
189
- counterfactuals: z.array(z.object({
190
- id: z.string(),
191
- name: z.string(),
192
- description: z.string(),
193
- conditions: z.array(z.object({
194
- factor: z.string(),
195
- value: z.string()
190
+ counterfactuals: z$1.array(z$1.object({
191
+ id: z$1.string(),
192
+ name: z$1.string(),
193
+ description: z$1.string(),
194
+ conditions: z$1.array(z$1.object({
195
+ factor: z$1.string(),
196
+ value: z$1.string()
196
197
  })),
197
- outcomes: z.array(z.object({
198
- description: z.string(),
199
- impact: z.enum(["positive", "negative", "neutral"]),
200
- magnitude: z.number().optional()
198
+ outcomes: z$1.array(z$1.object({
199
+ description: z$1.string(),
200
+ impact: z$1.enum(["positive", "negative", "neutral"]),
201
+ magnitude: z$1.number().optional()
201
202
  }))
202
203
  })).optional(),
203
- comparison: z.object({
204
- differences: z.array(z.object({
205
- aspect: z.string(),
206
- actual: z.string(),
207
- counterfactual: z.string(),
208
- significance: z.enum(["high", "medium", "low"])
204
+ comparison: z$1.object({
205
+ differences: z$1.array(z$1.object({
206
+ aspect: z$1.string(),
207
+ actual: z$1.string(),
208
+ counterfactual: z$1.string(),
209
+ significance: z$1.enum(["high", "medium", "low"])
209
210
  })),
210
- insights: z.array(z.string()),
211
- lessons: z.array(z.string())
211
+ insights: z$1.array(z$1.string()),
212
+ lessons: z$1.array(z$1.string())
212
213
  }).optional(),
213
- interventionPoint: z.object({
214
- description: z.string(),
215
- alternatives: z.array(z.string())
214
+ interventionPoint: z$1.object({
215
+ description: z$1.string(),
216
+ alternatives: z$1.array(z$1.string())
216
217
  }).optional(),
217
- causalChains: z.array(z.object({
218
- intervention: z.string(),
219
- steps: z.array(z.string()),
220
- finalOutcome: z.string()
218
+ causalChains: z$1.array(z$1.object({
219
+ intervention: z$1.string(),
220
+ steps: z$1.array(z$1.string()),
221
+ finalOutcome: z$1.string()
221
222
  })).optional(),
222
223
  // Analogical reasoning properties (v2.0)
223
- sourceDomain: z.object({
224
- id: z.string(),
225
- name: z.string(),
226
- description: z.string(),
227
- entities: z.array(z.object({
228
- id: z.string(),
229
- name: z.string(),
230
- type: z.string()
224
+ sourceDomain: z$1.object({
225
+ id: z$1.string(),
226
+ name: z$1.string(),
227
+ description: z$1.string(),
228
+ entities: z$1.array(z$1.object({
229
+ id: z$1.string(),
230
+ name: z$1.string(),
231
+ type: z$1.string()
231
232
  })),
232
- relations: z.array(z.object({
233
- id: z.string(),
234
- type: z.string(),
235
- from: z.string(),
236
- to: z.string()
233
+ relations: z$1.array(z$1.object({
234
+ id: z$1.string(),
235
+ type: z$1.string(),
236
+ from: z$1.string(),
237
+ to: z$1.string()
237
238
  }))
238
239
  }).optional(),
239
- targetDomain: z.object({
240
- id: z.string(),
241
- name: z.string(),
242
- description: z.string(),
243
- entities: z.array(z.object({
244
- id: z.string(),
245
- name: z.string(),
246
- type: z.string()
240
+ targetDomain: z$1.object({
241
+ id: z$1.string(),
242
+ name: z$1.string(),
243
+ description: z$1.string(),
244
+ entities: z$1.array(z$1.object({
245
+ id: z$1.string(),
246
+ name: z$1.string(),
247
+ type: z$1.string()
247
248
  })),
248
- relations: z.array(z.object({
249
- id: z.string(),
250
- type: z.string(),
251
- from: z.string(),
252
- to: z.string()
249
+ relations: z$1.array(z$1.object({
250
+ id: z$1.string(),
251
+ type: z$1.string(),
252
+ from: z$1.string(),
253
+ to: z$1.string()
253
254
  }))
254
255
  }).optional(),
255
- mapping: z.array(z.object({
256
- sourceEntityId: z.string(),
257
- targetEntityId: z.string(),
258
- justification: z.string(),
259
- confidence: z.number().min(0).max(1)
256
+ mapping: z$1.array(z$1.object({
257
+ sourceEntityId: z$1.string(),
258
+ targetEntityId: z$1.string(),
259
+ justification: z$1.string(),
260
+ confidence: z$1.number().min(0).max(1)
260
261
  })).optional(),
261
- insights: z.array(z.object({
262
- description: z.string(),
263
- sourceEvidence: z.string(),
264
- targetApplication: z.string()
262
+ insights: z$1.array(z$1.object({
263
+ description: z$1.string(),
264
+ sourceEvidence: z$1.string(),
265
+ targetApplication: z$1.string()
265
266
  })).optional(),
266
- inferences: z.array(z.object({
267
- sourcePattern: z.string(),
268
- targetPrediction: z.string(),
269
- confidence: z.number().min(0).max(1),
270
- needsVerification: z.boolean()
267
+ inferences: z$1.array(z$1.object({
268
+ sourcePattern: z$1.string(),
269
+ targetPrediction: z$1.string(),
270
+ confidence: z$1.number().min(0).max(1),
271
+ needsVerification: z$1.boolean()
271
272
  })).optional(),
272
- limitations: z.array(z.string()).optional(),
273
- analogyStrength: z.number().min(0).max(1).optional(),
273
+ limitations: z$1.array(z$1.string()).optional(),
274
+ analogyStrength: z$1.number().min(0).max(1).optional(),
274
275
  // Temporal reasoning properties (Phase 3, v2.1)
275
- timeline: z.object({
276
- id: z.string(),
277
- name: z.string(),
278
- timeUnit: z.enum(["milliseconds", "seconds", "minutes", "hours", "days", "months", "years"]),
279
- startTime: z.number().optional(),
280
- endTime: z.number().optional(),
281
- events: z.array(z.string())
276
+ timeline: z$1.object({
277
+ id: z$1.string(),
278
+ name: z$1.string(),
279
+ timeUnit: z$1.enum(["milliseconds", "seconds", "minutes", "hours", "days", "months", "years"]),
280
+ startTime: z$1.number().optional(),
281
+ endTime: z$1.number().optional(),
282
+ events: z$1.array(z$1.string())
282
283
  }).optional(),
283
- events: z.array(z.object({
284
- id: z.string(),
285
- name: z.string(),
286
- description: z.string(),
287
- timestamp: z.number(),
288
- duration: z.number().optional(),
289
- type: z.enum(["instant", "interval"]),
290
- properties: z.record(z.any())
284
+ events: z$1.array(z$1.object({
285
+ id: z$1.string(),
286
+ name: z$1.string(),
287
+ description: z$1.string(),
288
+ timestamp: z$1.number(),
289
+ duration: z$1.number().optional(),
290
+ type: z$1.enum(["instant", "interval"]),
291
+ properties: z$1.record(z$1.any())
291
292
  })).optional(),
292
- intervals: z.array(z.object({
293
- id: z.string(),
294
- name: z.string(),
295
- start: z.number(),
296
- end: z.number(),
297
- overlaps: z.array(z.string()).optional(),
298
- contains: z.array(z.string()).optional()
293
+ intervals: z$1.array(z$1.object({
294
+ id: z$1.string(),
295
+ name: z$1.string(),
296
+ start: z$1.number(),
297
+ end: z$1.number(),
298
+ overlaps: z$1.array(z$1.string()).optional(),
299
+ contains: z$1.array(z$1.string()).optional()
299
300
  })).optional(),
300
- constraints: z.array(z.object({
301
- id: z.string(),
302
- type: z.enum(["before", "after", "during", "overlaps", "meets", "starts", "finishes", "equals"]),
303
- subject: z.string(),
304
- object: z.string(),
305
- confidence: z.number().min(0).max(1)
301
+ constraints: z$1.array(z$1.object({
302
+ id: z$1.string(),
303
+ type: z$1.enum(["before", "after", "during", "overlaps", "meets", "starts", "finishes", "equals"]),
304
+ subject: z$1.string(),
305
+ object: z$1.string(),
306
+ confidence: z$1.number().min(0).max(1)
306
307
  })).optional(),
307
- relations: z.array(z.object({
308
- id: z.string(),
309
- from: z.string(),
310
- to: z.string(),
311
- relationType: z.enum(["causes", "enables", "prevents", "precedes", "follows"]),
312
- strength: z.number().min(0).max(1),
313
- delay: z.number().optional()
308
+ relations: z$1.array(z$1.object({
309
+ id: z$1.string(),
310
+ from: z$1.string(),
311
+ to: z$1.string(),
312
+ relationType: z$1.enum(["causes", "enables", "prevents", "precedes", "follows"]),
313
+ strength: z$1.number().min(0).max(1),
314
+ delay: z$1.number().optional()
314
315
  })).optional(),
315
316
  // Game theory properties (Phase 3, v2.2)
316
- game: z.object({
317
- id: z.string(),
318
- name: z.string(),
319
- description: z.string(),
320
- type: z.enum(["normal_form", "extensive_form", "cooperative", "non_cooperative"]),
321
- numPlayers: z.number().int().min(2),
322
- isZeroSum: z.boolean(),
323
- isPerfectInformation: z.boolean()
317
+ game: z$1.object({
318
+ id: z$1.string(),
319
+ name: z$1.string(),
320
+ description: z$1.string(),
321
+ type: z$1.enum(["normal_form", "extensive_form", "cooperative", "non_cooperative"]),
322
+ numPlayers: z$1.number().int().min(2),
323
+ isZeroSum: z$1.boolean(),
324
+ isPerfectInformation: z$1.boolean()
324
325
  }).optional(),
325
- players: z.array(z.object({
326
- id: z.string(),
327
- name: z.string(),
328
- role: z.string().optional(),
329
- isRational: z.boolean(),
330
- availableStrategies: z.array(z.string())
326
+ players: z$1.array(z$1.object({
327
+ id: z$1.string(),
328
+ name: z$1.string(),
329
+ role: z$1.string().optional(),
330
+ isRational: z$1.boolean(),
331
+ availableStrategies: z$1.array(z$1.string())
331
332
  })).optional(),
332
- strategies: z.array(z.object({
333
- id: z.string(),
334
- playerId: z.string(),
335
- name: z.string(),
336
- description: z.string(),
337
- isPure: z.boolean(),
338
- probability: z.number().min(0).max(1).optional()
333
+ strategies: z$1.array(z$1.object({
334
+ id: z$1.string(),
335
+ playerId: z$1.string(),
336
+ name: z$1.string(),
337
+ description: z$1.string(),
338
+ isPure: z$1.boolean(),
339
+ probability: z$1.number().min(0).max(1).optional()
339
340
  })).optional(),
340
- payoffMatrix: z.object({
341
- players: z.array(z.string()),
342
- dimensions: z.array(z.number()),
343
- payoffs: z.array(z.object({
344
- strategyProfile: z.array(z.string()),
345
- payoffs: z.array(z.number())
341
+ payoffMatrix: z$1.object({
342
+ players: z$1.array(z$1.string()),
343
+ dimensions: z$1.array(z$1.number()),
344
+ payoffs: z$1.array(z$1.object({
345
+ strategyProfile: z$1.array(z$1.string()),
346
+ payoffs: z$1.array(z$1.number())
346
347
  }))
347
348
  }).optional(),
348
- nashEquilibria: z.array(z.object({
349
- id: z.string(),
350
- strategyProfile: z.array(z.string()),
351
- payoffs: z.array(z.number()),
352
- type: z.enum(["pure", "mixed"]),
353
- isStrict: z.boolean(),
354
- stability: z.number().min(0).max(1)
349
+ nashEquilibria: z$1.array(z$1.object({
350
+ id: z$1.string(),
351
+ strategyProfile: z$1.array(z$1.string()),
352
+ payoffs: z$1.array(z$1.number()),
353
+ type: z$1.enum(["pure", "mixed"]),
354
+ isStrict: z$1.boolean(),
355
+ stability: z$1.number().min(0).max(1)
355
356
  })).optional(),
356
- dominantStrategies: z.array(z.object({
357
- playerId: z.string(),
358
- strategyId: z.string(),
359
- type: z.enum(["strictly_dominant", "weakly_dominant"]),
360
- dominatesStrategies: z.array(z.string()),
361
- justification: z.string()
357
+ dominantStrategies: z$1.array(z$1.object({
358
+ playerId: z$1.string(),
359
+ strategyId: z$1.string(),
360
+ type: z$1.enum(["strictly_dominant", "weakly_dominant"]),
361
+ dominatesStrategies: z$1.array(z$1.string()),
362
+ justification: z$1.string()
362
363
  })).optional(),
363
- gameTree: z.object({
364
- rootNode: z.string(),
365
- nodes: z.array(z.object({
366
- id: z.string(),
367
- type: z.enum(["decision", "chance", "terminal"]),
368
- playerId: z.string().optional(),
369
- parentNode: z.string().optional(),
370
- childNodes: z.array(z.string()),
371
- action: z.string().optional(),
372
- probability: z.number().min(0).max(1).optional(),
373
- payoffs: z.array(z.number()).optional()
364
+ gameTree: z$1.object({
365
+ rootNode: z$1.string(),
366
+ nodes: z$1.array(z$1.object({
367
+ id: z$1.string(),
368
+ type: z$1.enum(["decision", "chance", "terminal"]),
369
+ playerId: z$1.string().optional(),
370
+ parentNode: z$1.string().optional(),
371
+ childNodes: z$1.array(z$1.string()),
372
+ action: z$1.string().optional(),
373
+ probability: z$1.number().min(0).max(1).optional(),
374
+ payoffs: z$1.array(z$1.number()).optional()
374
375
  })),
375
- informationSets: z.array(z.object({
376
- id: z.string(),
377
- playerId: z.string(),
378
- nodes: z.array(z.string()),
379
- availableActions: z.array(z.string())
376
+ informationSets: z$1.array(z$1.object({
377
+ id: z$1.string(),
378
+ playerId: z$1.string(),
379
+ nodes: z$1.array(z$1.string()),
380
+ availableActions: z$1.array(z$1.string())
380
381
  })).optional()
381
382
  }).optional(),
382
383
  // Evidential properties (Phase 3, v2.3)
383
- frameOfDiscernment: z.array(z.string()).optional(),
384
- beliefFunctions: z.array(z.object({
385
- id: z.string(),
386
- source: z.string(),
387
- massAssignments: z.array(z.object({
388
- hypothesisSet: z.array(z.string()),
389
- mass: z.number().min(0).max(1),
390
- justification: z.string()
384
+ frameOfDiscernment: z$1.array(z$1.string()).optional(),
385
+ beliefFunctions: z$1.array(z$1.object({
386
+ id: z$1.string(),
387
+ source: z$1.string(),
388
+ massAssignments: z$1.array(z$1.object({
389
+ hypothesisSet: z$1.array(z$1.string()),
390
+ mass: z$1.number().min(0).max(1),
391
+ justification: z$1.string()
391
392
  })),
392
- conflictMass: z.number().optional()
393
+ conflictMass: z$1.number().optional()
393
394
  })).optional(),
394
- combinedBelief: z.object({
395
- id: z.string(),
396
- source: z.string(),
397
- massAssignments: z.array(z.object({
398
- hypothesisSet: z.array(z.string()),
399
- mass: z.number().min(0).max(1),
400
- justification: z.string()
395
+ combinedBelief: z$1.object({
396
+ id: z$1.string(),
397
+ source: z$1.string(),
398
+ massAssignments: z$1.array(z$1.object({
399
+ hypothesisSet: z$1.array(z$1.string()),
400
+ mass: z$1.number().min(0).max(1),
401
+ justification: z$1.string()
401
402
  })),
402
- conflictMass: z.number().optional()
403
+ conflictMass: z$1.number().optional()
403
404
  }).optional(),
404
- plausibility: z.object({
405
- id: z.string(),
406
- assignments: z.array(z.object({
407
- hypothesisSet: z.array(z.string()),
408
- plausibility: z.number().min(0).max(1),
409
- belief: z.number().min(0).max(1),
410
- uncertaintyInterval: z.tuple([z.number(), z.number()])
405
+ plausibility: z$1.object({
406
+ id: z$1.string(),
407
+ assignments: z$1.array(z$1.object({
408
+ hypothesisSet: z$1.array(z$1.string()),
409
+ plausibility: z$1.number().min(0).max(1),
410
+ belief: z$1.number().min(0).max(1),
411
+ uncertaintyInterval: z$1.tuple([z$1.number(), z$1.number()])
411
412
  }))
412
413
  }).optional(),
413
- decisions: z.array(z.object({
414
- id: z.string(),
415
- name: z.string(),
416
- selectedHypothesis: z.array(z.string()),
417
- confidence: z.number().min(0).max(1),
418
- reasoning: z.string(),
419
- alternatives: z.array(z.object({
420
- hypothesis: z.array(z.string()),
421
- expectedUtility: z.number(),
422
- risk: z.number()
414
+ decisions: z$1.array(z$1.object({
415
+ id: z$1.string(),
416
+ name: z$1.string(),
417
+ selectedHypothesis: z$1.array(z$1.string()),
418
+ confidence: z$1.number().min(0).max(1),
419
+ reasoning: z$1.string(),
420
+ alternatives: z$1.array(z$1.object({
421
+ hypothesis: z$1.array(z$1.string()),
422
+ expectedUtility: z$1.number(),
423
+ risk: z$1.number()
423
424
  }))
424
425
  })).optional(),
425
426
  // First-Principles properties (Phase 3, v3.1.0)
426
- question: z.string().optional(),
427
- principles: z.array(z.object({
428
- id: z.string(),
429
- type: z.enum(["axiom", "definition", "observation", "logical_inference", "assumption"]),
430
- statement: z.string(),
431
- justification: z.string(),
432
- dependsOn: z.array(z.string()).optional(),
433
- confidence: z.number().min(0).max(1).optional()
427
+ question: z$1.string().optional(),
428
+ principles: z$1.array(z$1.object({
429
+ id: z$1.string(),
430
+ type: z$1.enum(["axiom", "definition", "observation", "logical_inference", "assumption"]),
431
+ statement: z$1.string(),
432
+ justification: z$1.string(),
433
+ dependsOn: z$1.array(z$1.string()).optional(),
434
+ confidence: z$1.number().min(0).max(1).optional()
434
435
  })).optional(),
435
- derivationSteps: z.array(z.object({
436
- stepNumber: z.number().int().positive(),
437
- principle: z.string(),
438
- inference: z.string(),
439
- logicalForm: z.string().optional(),
440
- confidence: z.number().min(0).max(1)
436
+ derivationSteps: z$1.array(z$1.object({
437
+ stepNumber: z$1.number().int().positive(),
438
+ principle: z$1.string(),
439
+ inference: z$1.string(),
440
+ logicalForm: z$1.string().optional(),
441
+ confidence: z$1.number().min(0).max(1)
441
442
  })).optional(),
442
- conclusion: z.object({
443
- statement: z.string(),
444
- derivationChain: z.array(z.number()),
445
- certainty: z.number().min(0).max(1),
446
- limitations: z.array(z.string()).optional()
443
+ conclusion: z$1.object({
444
+ statement: z$1.string(),
445
+ derivationChain: z$1.array(z$1.number()),
446
+ certainty: z$1.number().min(0).max(1),
447
+ limitations: z$1.array(z$1.string()).optional()
447
448
  }).optional(),
448
- alternativeInterpretations: z.array(z.string()).optional(),
449
+ alternativeInterpretations: z$1.array(z$1.string()).optional(),
449
450
  // Systems Thinking properties (Phase 4, v3.2.0)
450
- system: z.object({
451
- id: z.string(),
452
- name: z.string(),
453
- description: z.string(),
454
- boundary: z.string(),
455
- purpose: z.string(),
456
- timeHorizon: z.string().optional()
451
+ system: z$1.object({
452
+ id: z$1.string(),
453
+ name: z$1.string(),
454
+ description: z$1.string(),
455
+ boundary: z$1.string(),
456
+ purpose: z$1.string(),
457
+ timeHorizon: z$1.string().optional()
457
458
  }).optional(),
458
- components: z.array(z.object({
459
- id: z.string(),
460
- name: z.string(),
461
- type: z.enum(["stock", "flow", "variable", "parameter", "delay"]),
462
- description: z.string(),
463
- unit: z.string().optional(),
464
- initialValue: z.number().optional(),
465
- formula: z.string().optional(),
466
- influencedBy: z.array(z.string()).optional()
459
+ components: z$1.array(z$1.object({
460
+ id: z$1.string(),
461
+ name: z$1.string(),
462
+ type: z$1.enum(["stock", "flow", "variable", "parameter", "delay"]),
463
+ description: z$1.string(),
464
+ unit: z$1.string().optional(),
465
+ initialValue: z$1.number().optional(),
466
+ formula: z$1.string().optional(),
467
+ influencedBy: z$1.array(z$1.string()).optional()
467
468
  })).optional(),
468
- feedbackLoops: z.array(z.object({
469
- id: z.string(),
470
- name: z.string(),
471
- type: z.enum(["reinforcing", "balancing"]),
472
- description: z.string(),
473
- components: z.array(z.string()),
474
- polarity: z.enum(["+", "-"]),
475
- strength: z.number().min(0).max(1),
476
- delay: z.number().optional(),
477
- dominance: z.enum(["early", "middle", "late"]).optional()
469
+ feedbackLoops: z$1.array(z$1.object({
470
+ id: z$1.string(),
471
+ name: z$1.string(),
472
+ type: z$1.enum(["reinforcing", "balancing"]),
473
+ description: z$1.string(),
474
+ components: z$1.array(z$1.string()),
475
+ polarity: z$1.enum(["+", "-"]),
476
+ strength: z$1.number().min(0).max(1),
477
+ delay: z$1.number().optional(),
478
+ dominance: z$1.enum(["early", "middle", "late"]).optional()
478
479
  })).optional(),
479
- leveragePoints: z.array(z.object({
480
- id: z.string(),
481
- name: z.string(),
482
- location: z.string(),
483
- description: z.string(),
484
- effectiveness: z.number().min(0).max(1),
485
- difficulty: z.number().min(0).max(1),
486
- type: z.enum(["parameter", "feedback", "structure", "goal", "paradigm"]),
487
- interventionExamples: z.array(z.string())
480
+ leveragePoints: z$1.array(z$1.object({
481
+ id: z$1.string(),
482
+ name: z$1.string(),
483
+ location: z$1.string(),
484
+ description: z$1.string(),
485
+ effectiveness: z$1.number().min(0).max(1),
486
+ difficulty: z$1.number().min(0).max(1),
487
+ type: z$1.enum(["parameter", "feedback", "structure", "goal", "paradigm"]),
488
+ interventionExamples: z$1.array(z$1.string())
488
489
  })).optional(),
489
- behaviors: z.array(z.object({
490
- id: z.string(),
491
- name: z.string(),
492
- description: z.string(),
493
- pattern: z.enum(["growth", "decline", "oscillation", "equilibrium", "chaos", "overshoot_collapse"]),
494
- causes: z.array(z.string()),
495
- timeframe: z.string(),
496
- unintendedConsequences: z.array(z.string()).optional()
490
+ behaviors: z$1.array(z$1.object({
491
+ id: z$1.string(),
492
+ name: z$1.string(),
493
+ description: z$1.string(),
494
+ pattern: z$1.enum(["growth", "decline", "oscillation", "equilibrium", "chaos", "overshoot_collapse"]),
495
+ causes: z$1.array(z$1.string()),
496
+ timeframe: z$1.string(),
497
+ unintendedConsequences: z$1.array(z$1.string()).optional()
497
498
  })).optional(),
498
499
  // Scientific Method properties (Phase 4, v3.2.0)
499
- researchQuestion: z.object({
500
- id: z.string(),
501
- question: z.string(),
502
- background: z.string(),
503
- rationale: z.string(),
504
- significance: z.string(),
505
- variables: z.object({
506
- independent: z.array(z.string()),
507
- dependent: z.array(z.string()),
508
- control: z.array(z.string())
500
+ researchQuestion: z$1.object({
501
+ id: z$1.string(),
502
+ question: z$1.string(),
503
+ background: z$1.string(),
504
+ rationale: z$1.string(),
505
+ significance: z$1.string(),
506
+ variables: z$1.object({
507
+ independent: z$1.array(z$1.string()),
508
+ dependent: z$1.array(z$1.string()),
509
+ control: z$1.array(z$1.string())
509
510
  })
510
511
  }).optional(),
511
- scientificHypotheses: z.array(z.object({
512
- id: z.string(),
513
- type: z.enum(["null", "alternative", "directional", "non_directional"]),
514
- statement: z.string(),
515
- prediction: z.string(),
516
- rationale: z.string(),
517
- testable: z.boolean(),
518
- falsifiable: z.boolean()
512
+ scientificHypotheses: z$1.array(z$1.object({
513
+ id: z$1.string(),
514
+ type: z$1.enum(["null", "alternative", "directional", "non_directional"]),
515
+ statement: z$1.string(),
516
+ prediction: z$1.string(),
517
+ rationale: z$1.string(),
518
+ testable: z$1.boolean(),
519
+ falsifiable: z$1.boolean()
519
520
  })).optional(),
520
- experiment: z.object({
521
- id: z.string(),
522
- type: z.enum(["experimental", "quasi_experimental", "observational", "correlational"]),
523
- design: z.string(),
524
- sampleSize: z.number().int().positive(),
525
- sampleSizeJustification: z.string().optional(),
526
- randomization: z.boolean(),
527
- blinding: z.enum(["none", "single", "double", "triple"]).optional(),
528
- controls: z.array(z.string()),
529
- procedure: z.array(z.string()),
530
- materials: z.array(z.string()).optional(),
531
- duration: z.string().optional(),
532
- ethicalConsiderations: z.array(z.string()).optional()
521
+ experiment: z$1.object({
522
+ id: z$1.string(),
523
+ type: z$1.enum(["experimental", "quasi_experimental", "observational", "correlational"]),
524
+ design: z$1.string(),
525
+ sampleSize: z$1.number().int().positive(),
526
+ sampleSizeJustification: z$1.string().optional(),
527
+ randomization: z$1.boolean(),
528
+ blinding: z$1.enum(["none", "single", "double", "triple"]).optional(),
529
+ controls: z$1.array(z$1.string()),
530
+ procedure: z$1.array(z$1.string()),
531
+ materials: z$1.array(z$1.string()).optional(),
532
+ duration: z$1.string().optional(),
533
+ ethicalConsiderations: z$1.array(z$1.string()).optional()
533
534
  }).optional(),
534
- dataCollection: z.object({
535
- id: z.string(),
536
- method: z.array(z.string()),
537
- instruments: z.array(z.string()),
538
- dataQuality: z.object({
539
- completeness: z.number().min(0).max(1),
540
- reliability: z.number().min(0).max(1),
541
- validity: z.number().min(0).max(1)
535
+ dataCollection: z$1.object({
536
+ id: z$1.string(),
537
+ method: z$1.array(z$1.string()),
538
+ instruments: z$1.array(z$1.string()),
539
+ dataQuality: z$1.object({
540
+ completeness: z$1.number().min(0).max(1),
541
+ reliability: z$1.number().min(0).max(1),
542
+ validity: z$1.number().min(0).max(1)
542
543
  }),
543
- limitations: z.array(z.string()).optional()
544
+ limitations: z$1.array(z$1.string()).optional()
544
545
  }).optional(),
545
- statisticalAnalysis: z.object({
546
- id: z.string(),
547
- tests: z.array(z.object({
548
- id: z.string(),
549
- name: z.string(),
550
- hypothesisTested: z.string(),
551
- testStatistic: z.number(),
552
- pValue: z.number().min(0).max(1),
553
- confidenceInterval: z.tuple([z.number(), z.number()]).optional(),
554
- alpha: z.number().min(0).max(1),
555
- result: z.enum(["reject_null", "fail_to_reject_null"]),
556
- interpretation: z.string()
546
+ statisticalAnalysis: z$1.object({
547
+ id: z$1.string(),
548
+ tests: z$1.array(z$1.object({
549
+ id: z$1.string(),
550
+ name: z$1.string(),
551
+ hypothesisTested: z$1.string(),
552
+ testStatistic: z$1.number(),
553
+ pValue: z$1.number().min(0).max(1),
554
+ confidenceInterval: z$1.tuple([z$1.number(), z$1.number()]).optional(),
555
+ alpha: z$1.number().min(0).max(1),
556
+ result: z$1.enum(["reject_null", "fail_to_reject_null"]),
557
+ interpretation: z$1.string()
557
558
  })),
558
- summary: z.string(),
559
- effectSize: z.object({
560
- type: z.string(),
561
- value: z.number(),
562
- interpretation: z.string()
559
+ summary: z$1.string(),
560
+ effectSize: z$1.object({
561
+ type: z$1.string(),
562
+ value: z$1.number(),
563
+ interpretation: z$1.string()
563
564
  }).optional(),
564
- powerAnalysis: z.object({
565
- power: z.number().min(0).max(1),
566
- alpha: z.number().min(0).max(1),
567
- interpretation: z.string()
565
+ powerAnalysis: z$1.object({
566
+ power: z$1.number().min(0).max(1),
567
+ alpha: z$1.number().min(0).max(1),
568
+ interpretation: z$1.string()
568
569
  }).optional()
569
570
  }).optional(),
570
- scientificConclusion: z.object({
571
- id: z.string(),
572
- statement: z.string(),
573
- supportedHypotheses: z.array(z.string()),
574
- rejectedHypotheses: z.array(z.string()),
575
- confidence: z.number().min(0).max(1),
576
- limitations: z.array(z.string()),
577
- alternativeExplanations: z.array(z.string()).optional(),
578
- futureDirections: z.array(z.string()),
579
- replicationConsiderations: z.array(z.string()),
580
- practicalImplications: z.array(z.string()).optional(),
581
- theoreticalImplications: z.array(z.string()).optional()
571
+ scientificConclusion: z$1.object({
572
+ id: z$1.string(),
573
+ statement: z$1.string(),
574
+ supportedHypotheses: z$1.array(z$1.string()),
575
+ rejectedHypotheses: z$1.array(z$1.string()),
576
+ confidence: z$1.number().min(0).max(1),
577
+ limitations: z$1.array(z$1.string()),
578
+ alternativeExplanations: z$1.array(z$1.string()).optional(),
579
+ futureDirections: z$1.array(z$1.string()),
580
+ replicationConsiderations: z$1.array(z$1.string()),
581
+ practicalImplications: z$1.array(z$1.string()).optional(),
582
+ theoreticalImplications: z$1.array(z$1.string()).optional()
582
583
  }).optional(),
583
584
  // Optimization properties (Phase 4, v3.2.0)
584
- optimizationProblem: z.object({
585
- id: z.string(),
586
- name: z.string(),
587
- description: z.string(),
588
- type: z.enum(["linear", "nonlinear", "integer", "mixed_integer", "constraint_satisfaction", "multi_objective"]),
589
- approach: z.enum(["exact", "heuristic", "metaheuristic", "approximation"]).optional(),
590
- complexity: z.string().optional()
585
+ optimizationProblem: z$1.object({
586
+ id: z$1.string(),
587
+ name: z$1.string(),
588
+ description: z$1.string(),
589
+ type: z$1.enum(["linear", "nonlinear", "integer", "mixed_integer", "constraint_satisfaction", "multi_objective"]),
590
+ approach: z$1.enum(["exact", "heuristic", "metaheuristic", "approximation"]).optional(),
591
+ complexity: z$1.string().optional()
591
592
  }).optional(),
592
- decisionVariables: z.array(z.object({
593
- id: z.string(),
594
- name: z.string(),
595
- description: z.string(),
596
- type: z.enum(["continuous", "integer", "binary", "categorical"]),
597
- unit: z.string().optional(),
598
- semantics: z.string()
593
+ decisionVariables: z$1.array(z$1.object({
594
+ id: z$1.string(),
595
+ name: z$1.string(),
596
+ description: z$1.string(),
597
+ type: z$1.enum(["continuous", "integer", "binary", "categorical"]),
598
+ unit: z$1.string().optional(),
599
+ semantics: z$1.string()
599
600
  })).optional(),
600
- optimizationConstraints: z.array(z.object({
601
- id: z.string(),
602
- name: z.string(),
603
- description: z.string(),
604
- type: z.enum(["hard", "soft"]),
605
- formula: z.string(),
606
- variables: z.array(z.string()),
607
- penalty: z.number().optional(),
608
- rationale: z.string(),
609
- priority: z.number().optional()
601
+ optimizationConstraints: z$1.array(z$1.object({
602
+ id: z$1.string(),
603
+ name: z$1.string(),
604
+ description: z$1.string(),
605
+ type: z$1.enum(["hard", "soft"]),
606
+ formula: z$1.string(),
607
+ variables: z$1.array(z$1.string()),
608
+ penalty: z$1.number().optional(),
609
+ rationale: z$1.string(),
610
+ priority: z$1.number().optional()
610
611
  })).optional(),
611
- objectives: z.array(z.object({
612
- id: z.string(),
613
- name: z.string(),
614
- description: z.string(),
615
- type: z.enum(["minimize", "maximize"]),
616
- formula: z.string(),
617
- variables: z.array(z.string()),
618
- weight: z.number().min(0).max(1).optional(),
619
- units: z.string().optional(),
620
- idealValue: z.number().optional(),
621
- acceptableRange: z.tuple([z.number(), z.number()]).optional()
612
+ objectives: z$1.array(z$1.object({
613
+ id: z$1.string(),
614
+ name: z$1.string(),
615
+ description: z$1.string(),
616
+ type: z$1.enum(["minimize", "maximize"]),
617
+ formula: z$1.string(),
618
+ variables: z$1.array(z$1.string()),
619
+ weight: z$1.number().min(0).max(1).optional(),
620
+ units: z$1.string().optional(),
621
+ idealValue: z$1.number().optional(),
622
+ acceptableRange: z$1.tuple([z$1.number(), z$1.number()]).optional()
622
623
  })).optional(),
623
- solution: z.object({
624
- id: z.string(),
625
- type: z.enum(["optimal", "feasible", "infeasible", "unbounded", "approximate"]),
626
- variableValues: z.record(z.union([z.number(), z.string()])),
627
- objectiveValues: z.record(z.number()),
628
- quality: z.number().min(0).max(1),
629
- computationTime: z.number().optional(),
630
- iterations: z.number().optional(),
631
- method: z.string().optional(),
632
- guarantees: z.array(z.string()).optional()
624
+ solution: z$1.object({
625
+ id: z$1.string(),
626
+ type: z$1.enum(["optimal", "feasible", "infeasible", "unbounded", "approximate"]),
627
+ variableValues: z$1.record(z$1.union([z$1.number(), z$1.string()])),
628
+ objectiveValues: z$1.record(z$1.number()),
629
+ quality: z$1.number().min(0).max(1),
630
+ computationTime: z$1.number().optional(),
631
+ iterations: z$1.number().optional(),
632
+ method: z$1.string().optional(),
633
+ guarantees: z$1.array(z$1.string()).optional()
633
634
  }).optional(),
634
- sensitivityAnalysis: z.object({
635
- id: z.string(),
636
- robustness: z.number().min(0).max(1),
637
- criticalConstraints: z.array(z.string()),
638
- shadowPrices: z.record(z.number()).optional(),
639
- recommendations: z.array(z.string())
635
+ sensitivityAnalysis: z$1.object({
636
+ id: z$1.string(),
637
+ robustness: z$1.number().min(0).max(1),
638
+ criticalConstraints: z$1.array(z$1.string()),
639
+ shadowPrices: z$1.record(z$1.number()).optional(),
640
+ recommendations: z$1.array(z$1.string())
640
641
  }).optional(),
641
642
  // Formal Logic properties (Phase 4, v3.2.0)
642
- propositions: z.array(z.object({
643
- id: z.string(),
644
- symbol: z.string(),
645
- statement: z.string(),
646
- truthValue: z.boolean().optional(),
647
- type: z.enum(["atomic", "compound"]),
648
- formula: z.string().optional()
643
+ propositions: z$1.array(z$1.object({
644
+ id: z$1.string(),
645
+ symbol: z$1.string(),
646
+ statement: z$1.string(),
647
+ truthValue: z$1.boolean().optional(),
648
+ type: z$1.enum(["atomic", "compound"]),
649
+ formula: z$1.string().optional()
649
650
  })).optional(),
650
- logicalInferences: z.array(z.object({
651
- id: z.string(),
652
- rule: z.enum(["modus_ponens", "modus_tollens", "hypothetical_syllogism", "disjunctive_syllogism", "conjunction", "simplification", "addition", "resolution", "contradiction", "excluded_middle"]),
653
- premises: z.array(z.string()),
654
- conclusion: z.string(),
655
- justification: z.string(),
656
- valid: z.boolean()
651
+ logicalInferences: z$1.array(z$1.object({
652
+ id: z$1.string(),
653
+ rule: z$1.enum(["modus_ponens", "modus_tollens", "hypothetical_syllogism", "disjunctive_syllogism", "conjunction", "simplification", "addition", "resolution", "contradiction", "excluded_middle"]),
654
+ premises: z$1.array(z$1.string()),
655
+ conclusion: z$1.string(),
656
+ justification: z$1.string(),
657
+ valid: z$1.boolean()
657
658
  })).optional(),
658
- logicalProof: z.object({
659
- id: z.string(),
660
- theorem: z.string(),
661
- technique: z.enum(["direct", "contradiction", "contrapositive", "cases", "induction", "natural_deduction", "resolution", "semantic_tableaux"]),
662
- steps: z.array(z.object({
663
- stepNumber: z.number().int().positive(),
664
- statement: z.string(),
665
- formula: z.string().optional(),
666
- justification: z.string(),
667
- rule: z.enum(["modus_ponens", "modus_tollens", "hypothetical_syllogism", "disjunctive_syllogism", "conjunction", "simplification", "addition", "resolution", "contradiction", "excluded_middle"]).optional(),
668
- referencesSteps: z.array(z.number()).optional(),
669
- isAssumption: z.boolean().optional(),
670
- dischargesAssumption: z.number().optional()
659
+ logicalProof: z$1.object({
660
+ id: z$1.string(),
661
+ theorem: z$1.string(),
662
+ technique: z$1.enum(["direct", "contradiction", "contrapositive", "cases", "induction", "natural_deduction", "resolution", "semantic_tableaux"]),
663
+ steps: z$1.array(z$1.object({
664
+ stepNumber: z$1.number().int().positive(),
665
+ statement: z$1.string(),
666
+ formula: z$1.string().optional(),
667
+ justification: z$1.string(),
668
+ rule: z$1.enum(["modus_ponens", "modus_tollens", "hypothetical_syllogism", "disjunctive_syllogism", "conjunction", "simplification", "addition", "resolution", "contradiction", "excluded_middle"]).optional(),
669
+ referencesSteps: z$1.array(z$1.number()).optional(),
670
+ isAssumption: z$1.boolean().optional(),
671
+ dischargesAssumption: z$1.number().optional()
671
672
  })),
672
- conclusion: z.string(),
673
- valid: z.boolean(),
674
- completeness: z.number().min(0).max(1),
675
- assumptions: z.array(z.string()).optional()
673
+ conclusion: z$1.string(),
674
+ valid: z$1.boolean(),
675
+ completeness: z$1.number().min(0).max(1),
676
+ assumptions: z$1.array(z$1.string()).optional()
676
677
  }).optional(),
677
- truthTable: z.object({
678
- id: z.string(),
679
- propositions: z.array(z.string()),
680
- formula: z.string().optional(),
681
- rows: z.array(z.object({
682
- rowNumber: z.number().int().positive(),
683
- assignments: z.record(z.boolean()),
684
- result: z.boolean()
678
+ truthTable: z$1.object({
679
+ id: z$1.string(),
680
+ propositions: z$1.array(z$1.string()),
681
+ formula: z$1.string().optional(),
682
+ rows: z$1.array(z$1.object({
683
+ rowNumber: z$1.number().int().positive(),
684
+ assignments: z$1.record(z$1.boolean()),
685
+ result: z$1.boolean()
685
686
  })),
686
- isTautology: z.boolean(),
687
- isContradiction: z.boolean(),
688
- isContingent: z.boolean()
687
+ isTautology: z$1.boolean(),
688
+ isContradiction: z$1.boolean(),
689
+ isContingent: z$1.boolean()
689
690
  }).optional(),
690
- satisfiability: z.object({
691
- id: z.string(),
692
- formula: z.string(),
693
- satisfiable: z.boolean(),
694
- model: z.record(z.boolean()).optional(),
695
- method: z.enum(["dpll", "cdcl", "resolution", "truth_table", "other"]),
696
- complexity: z.string().optional(),
697
- explanation: z.string()
691
+ satisfiability: z$1.object({
692
+ id: z$1.string(),
693
+ formula: z$1.string(),
694
+ satisfiable: z$1.boolean(),
695
+ model: z$1.record(z$1.boolean()).optional(),
696
+ method: z$1.enum(["dpll", "cdcl", "resolution", "truth_table", "other"]),
697
+ complexity: z$1.string().optional(),
698
+ explanation: z$1.string()
698
699
  }).optional(),
699
- action: z.enum(["add_thought", "summarize", "export", "switch_mode", "get_session", "recommend_mode"]).default("add_thought"),
700
- exportFormat: z.enum(["markdown", "latex", "json", "html", "jupyter", "mermaid", "dot", "ascii"]).optional(),
701
- newMode: z.enum(["sequential", "shannon", "mathematics", "physics", "hybrid", "abductive", "causal", "bayesian", "counterfactual", "analogical", "temporal", "gametheory", "evidential", "firstprinciples", "systemsthinking", "scientificmethod", "optimization", "formallogic"]).optional(),
700
+ action: z$1.enum(["add_thought", "summarize", "export", "switch_mode", "get_session", "recommend_mode"]).default("add_thought"),
701
+ exportFormat: z$1.enum(["markdown", "latex", "json", "html", "jupyter", "mermaid", "dot", "ascii"]).optional(),
702
+ newMode: z$1.enum(["sequential", "shannon", "mathematics", "physics", "hybrid", "abductive", "causal", "bayesian", "counterfactual", "analogical", "temporal", "gametheory", "evidential", "firstprinciples", "systemsthinking", "scientificmethod", "optimization", "formallogic"]).optional(),
702
703
  // Mode recommendation parameters (v2.4)
703
- problemType: z.string().optional(),
704
- problemCharacteristics: z.object({
705
- domain: z.string(),
706
- complexity: z.enum(["low", "medium", "high"]),
707
- uncertainty: z.enum(["low", "medium", "high"]),
708
- timeDependent: z.boolean(),
709
- multiAgent: z.boolean(),
710
- requiresProof: z.boolean(),
711
- requiresQuantification: z.boolean(),
712
- hasIncompleteInfo: z.boolean(),
713
- requiresExplanation: z.boolean(),
714
- hasAlternatives: z.boolean()
704
+ problemType: z$1.string().optional(),
705
+ problemCharacteristics: z$1.object({
706
+ domain: z$1.string(),
707
+ complexity: z$1.enum(["low", "medium", "high"]),
708
+ uncertainty: z$1.enum(["low", "medium", "high"]),
709
+ timeDependent: z$1.boolean(),
710
+ multiAgent: z$1.boolean(),
711
+ requiresProof: z$1.boolean(),
712
+ requiresQuantification: z$1.boolean(),
713
+ hasIncompleteInfo: z$1.boolean(),
714
+ requiresExplanation: z$1.boolean(),
715
+ hasAlternatives: z$1.boolean()
715
716
  }).optional(),
716
- includeCombinations: z.boolean().optional()
717
+ includeCombinations: z$1.boolean().optional()
717
718
  });
718
719
  generateMcpSchema = () => {
719
720
  const jsonSchema = zodToJsonSchema(ThinkingToolSchema, {
720
- target: "jsonSchema2019-09",
721
+ target: "jsonSchema2020-12",
721
722
  $refStrategy: "none"
722
723
  });
723
724
  if (jsonSchema && typeof jsonSchema === "object") {
@@ -5392,7 +5393,7 @@ init_esm_shims();
5392
5393
  init_esm_shims();
5393
5394
  function generateToolSchema(zodSchema, name, description) {
5394
5395
  const jsonSchema = zodToJsonSchema(zodSchema, {
5395
- target: "jsonSchema2019-09",
5396
+ target: "jsonSchema2020-12",
5396
5397
  $refStrategy: "none"
5397
5398
  });
5398
5399
  if (jsonSchema && typeof jsonSchema === "object") {