deepthinking-mcp 4.3.3 → 4.3.4

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 +569 -570
  2. package/dist/index.js.map +1 -1
  3. package/package.json +1 -1
package/dist/index.js CHANGED
@@ -1,14 +1,13 @@
1
1
  #!/usr/bin/env node
2
2
  import { dirname, join } from 'path';
3
3
  import { fileURLToPath } from 'url';
4
- import { z as z$1 } from 'zod/v3';
4
+ import { z } 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';
12
11
 
13
12
  var __defProp = Object.defineProperty;
14
13
  var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -34,687 +33,687 @@ var ThinkingToolSchema, generateMcpSchema, thinkingTool;
34
33
  var init_thinking = __esm({
35
34
  "src/tools/thinking.ts"() {
36
35
  init_esm_shims();
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()
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()
58
57
  }).optional(),
59
- proofStrategy: z$1.object({
60
- type: z$1.enum(["direct", "contradiction", "induction", "construction", "contrapositive"]),
61
- steps: z$1.array(z$1.string())
58
+ proofStrategy: z.object({
59
+ type: z.enum(["direct", "contradiction", "induction", "construction", "contrapositive"]),
60
+ steps: z.array(z.string())
62
61
  }).optional(),
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"])
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"])
70
69
  }).optional(),
71
- physicalInterpretation: z$1.object({
72
- quantity: z$1.string(),
73
- units: z$1.string(),
74
- conservationLaws: z$1.array(z$1.string())
70
+ physicalInterpretation: z.object({
71
+ quantity: z.string(),
72
+ units: z.string(),
73
+ conservationLaws: z.array(z.string())
75
74
  }).optional(),
76
75
  // Abductive reasoning properties (v2.0)
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)
76
+ observations: z.array(z.object({
77
+ id: z.string(),
78
+ description: z.string(),
79
+ confidence: z.number().min(0).max(1)
81
80
  })).optional(),
82
- hypotheses: z$1.array(z$1.object({
83
- id: z$1.string(),
81
+ hypotheses: z.array(z.object({
82
+ id: z.string(),
84
83
  // Abductive fields
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(),
84
+ explanation: z.string().optional(),
85
+ assumptions: z.array(z.string()).optional(),
86
+ predictions: z.array(z.string()).optional(),
87
+ score: z.number().optional(),
89
88
  // Evidential fields
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()
89
+ name: z.string().optional(),
90
+ description: z.string().optional(),
91
+ mutuallyExclusive: z.boolean().optional(),
92
+ subsets: z.array(z.string()).optional()
94
93
  })).optional(),
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()
94
+ evaluationCriteria: z.object({
95
+ parsimony: z.number(),
96
+ explanatoryPower: z.number(),
97
+ plausibility: z.number(),
98
+ testability: z.boolean()
100
99
  }).optional(),
101
- evidence: z$1.array(z$1.object({
102
- id: z$1.string(),
103
- description: z$1.string(),
100
+ evidence: z.array(z.object({
101
+ id: z.string(),
102
+ description: z.string(),
104
103
  // Abductive fields
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(),
104
+ hypothesisId: z.string().optional(),
105
+ type: z.enum(["supporting", "contradicting", "neutral"]).optional(),
106
+ strength: z.number().min(0).max(1).optional(),
108
107
  // Evidential fields
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()
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()
114
113
  })).optional(),
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()
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()
121
120
  }).optional(),
122
121
  // Causal reasoning properties (v2.0)
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()
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()
129
128
  })),
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)
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)
135
134
  }))
136
135
  }).optional(),
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()
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()
144
143
  }))
145
144
  })).optional(),
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"])
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"])
151
150
  })).optional(),
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()
151
+ confounders: z.array(z.object({
152
+ nodeId: z.string(),
153
+ affects: z.array(z.string()),
154
+ description: z.string()
156
155
  })).optional(),
157
156
  // Bayesian reasoning properties (v2.0)
158
- hypothesis: z$1.object({
159
- id: z$1.string(),
160
- statement: z$1.string()
157
+ hypothesis: z.object({
158
+ id: z.string(),
159
+ statement: z.string()
161
160
  }).optional(),
162
- prior: z$1.object({
163
- probability: z$1.number().min(0).max(1),
164
- justification: z$1.string()
161
+ prior: z.object({
162
+ probability: z.number().min(0).max(1),
163
+ justification: z.string()
165
164
  }).optional(),
166
- likelihood: z$1.object({
167
- probability: z$1.number().min(0).max(1),
168
- description: z$1.string()
165
+ likelihood: z.object({
166
+ probability: z.number().min(0).max(1),
167
+ description: z.string()
169
168
  }).optional(),
170
- posterior: z$1.object({
171
- probability: z$1.number().min(0).max(1),
172
- calculation: z$1.string()
169
+ posterior: z.object({
170
+ probability: z.number().min(0).max(1),
171
+ calculation: z.string()
173
172
  }).optional(),
174
- bayesFactor: z$1.number().optional(),
173
+ bayesFactor: z.number().optional(),
175
174
  // Counterfactual reasoning properties (v2.0)
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()
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()
183
182
  })),
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()
183
+ outcomes: z.array(z.object({
184
+ description: z.string(),
185
+ impact: z.enum(["positive", "negative", "neutral"]),
186
+ magnitude: z.number().optional()
188
187
  }))
189
188
  }).optional(),
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()
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()
197
196
  })),
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()
197
+ outcomes: z.array(z.object({
198
+ description: z.string(),
199
+ impact: z.enum(["positive", "negative", "neutral"]),
200
+ magnitude: z.number().optional()
202
201
  }))
203
202
  })).optional(),
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"])
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"])
210
209
  })),
211
- insights: z$1.array(z$1.string()),
212
- lessons: z$1.array(z$1.string())
210
+ insights: z.array(z.string()),
211
+ lessons: z.array(z.string())
213
212
  }).optional(),
214
- interventionPoint: z$1.object({
215
- description: z$1.string(),
216
- alternatives: z$1.array(z$1.string())
213
+ interventionPoint: z.object({
214
+ description: z.string(),
215
+ alternatives: z.array(z.string())
217
216
  }).optional(),
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()
217
+ causalChains: z.array(z.object({
218
+ intervention: z.string(),
219
+ steps: z.array(z.string()),
220
+ finalOutcome: z.string()
222
221
  })).optional(),
223
222
  // Analogical reasoning properties (v2.0)
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()
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()
232
231
  })),
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()
232
+ relations: z.array(z.object({
233
+ id: z.string(),
234
+ type: z.string(),
235
+ from: z.string(),
236
+ to: z.string()
238
237
  }))
239
238
  }).optional(),
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()
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()
248
247
  })),
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()
248
+ relations: z.array(z.object({
249
+ id: z.string(),
250
+ type: z.string(),
251
+ from: z.string(),
252
+ to: z.string()
254
253
  }))
255
254
  }).optional(),
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)
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)
261
260
  })).optional(),
262
- insights: z$1.array(z$1.object({
263
- description: z$1.string(),
264
- sourceEvidence: z$1.string(),
265
- targetApplication: z$1.string()
261
+ insights: z.array(z.object({
262
+ description: z.string(),
263
+ sourceEvidence: z.string(),
264
+ targetApplication: z.string()
266
265
  })).optional(),
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()
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()
272
271
  })).optional(),
273
- limitations: z$1.array(z$1.string()).optional(),
274
- analogyStrength: z$1.number().min(0).max(1).optional(),
272
+ limitations: z.array(z.string()).optional(),
273
+ analogyStrength: z.number().min(0).max(1).optional(),
275
274
  // Temporal reasoning properties (Phase 3, v2.1)
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())
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())
283
282
  }).optional(),
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())
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())
292
291
  })).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()
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()
300
299
  })).optional(),
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)
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)
307
306
  })).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()
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()
315
314
  })).optional(),
316
315
  // Game theory properties (Phase 3, v2.2)
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()
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()
325
324
  }).optional(),
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())
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())
332
331
  })).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()
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()
340
339
  })).optional(),
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())
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())
347
346
  }))
348
347
  }).optional(),
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)
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)
356
355
  })).optional(),
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()
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()
363
362
  })).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()
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()
375
374
  })),
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())
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())
381
380
  })).optional()
382
381
  }).optional(),
383
382
  // Evidential properties (Phase 3, v2.3)
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()
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()
392
391
  })),
393
- conflictMass: z$1.number().optional()
392
+ conflictMass: z.number().optional()
394
393
  })).optional(),
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()
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()
402
401
  })),
403
- conflictMass: z$1.number().optional()
402
+ conflictMass: z.number().optional()
404
403
  }).optional(),
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()])
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()])
412
411
  }))
413
412
  }).optional(),
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()
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()
424
423
  }))
425
424
  })).optional(),
426
425
  // First-Principles properties (Phase 3, v3.1.0)
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()
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()
435
434
  })).optional(),
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)
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)
442
441
  })).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()
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()
448
447
  }).optional(),
449
- alternativeInterpretations: z$1.array(z$1.string()).optional(),
448
+ alternativeInterpretations: z.array(z.string()).optional(),
450
449
  // Systems Thinking properties (Phase 4, v3.2.0)
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()
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()
458
457
  }).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()
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()
468
467
  })).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()
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()
479
478
  })).optional(),
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())
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())
489
488
  })).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()
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()
498
497
  })).optional(),
499
498
  // Scientific Method properties (Phase 4, v3.2.0)
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())
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())
510
509
  })
511
510
  }).optional(),
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()
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()
520
519
  })).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()
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()
534
533
  }).optional(),
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)
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)
543
542
  }),
544
- limitations: z$1.array(z$1.string()).optional()
543
+ limitations: z.array(z.string()).optional()
545
544
  }).optional(),
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()
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()
558
557
  })),
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()
558
+ summary: z.string(),
559
+ effectSize: z.object({
560
+ type: z.string(),
561
+ value: z.number(),
562
+ interpretation: z.string()
564
563
  }).optional(),
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()
564
+ powerAnalysis: z.object({
565
+ power: z.number().min(0).max(1),
566
+ alpha: z.number().min(0).max(1),
567
+ interpretation: z.string()
569
568
  }).optional()
570
569
  }).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()
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()
583
582
  }).optional(),
584
583
  // Optimization properties (Phase 4, v3.2.0)
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()
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()
592
591
  }).optional(),
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()
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()
600
599
  })).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()
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()
611
610
  })).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()
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()
623
622
  })).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()
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()
634
633
  }).optional(),
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())
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())
641
640
  }).optional(),
642
641
  // Formal Logic properties (Phase 4, v3.2.0)
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()
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()
650
649
  })).optional(),
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()
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()
658
657
  })).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()
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()
672
671
  })),
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()
672
+ conclusion: z.string(),
673
+ valid: z.boolean(),
674
+ completeness: z.number().min(0).max(1),
675
+ assumptions: z.array(z.string()).optional()
677
676
  }).optional(),
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()
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()
686
685
  })),
687
- isTautology: z$1.boolean(),
688
- isContradiction: z$1.boolean(),
689
- isContingent: z$1.boolean()
686
+ isTautology: z.boolean(),
687
+ isContradiction: z.boolean(),
688
+ isContingent: z.boolean()
690
689
  }).optional(),
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()
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()
699
698
  }).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(),
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(),
703
702
  // Mode recommendation parameters (v2.4)
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()
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()
716
715
  }).optional(),
717
- includeCombinations: z$1.boolean().optional()
716
+ includeCombinations: z.boolean().optional()
718
717
  });
719
718
  generateMcpSchema = () => {
720
719
  const jsonSchema = zodToJsonSchema(ThinkingToolSchema, {