@arong8888/tulip-aibot-mcp 0.1.0

package/python/reasoning_tools.py

@@ -0,0 +1,220 @@
+"""Deterministic thinking aids for agents; not hidden reasoning or trade signals.
+
+No model/network/filesystem calls, no broker imports and no automatic trading.
+Qualitative tools organize caller-supplied evidence, not certify its truth.
+"""
+from copy import deepcopy
+import math
+
+
+def _text(value, label):
+    if not isinstance(value, str) or not value.strip() or len(value) > 2000:
+        raise ValueError(f"{label}: expected nonempty text up to 2000 characters")
+    return value.strip()
+
+
+def _number(value, label, low, high):
+    if type(value) not in (int, float) or not low <= value <= high:
+        raise ValueError(f"{label}: expected finite number in [{low}, {high}]")
+    if not math.isfinite(value):
+        raise ValueError(f"{label}: number must be finite")
+    return float(value)
+
+
+def _items(value, label, minimum=0, maximum=50):
+    if not isinstance(value, list) or not minimum <= len(value) <= maximum:
+        raise ValueError(f"{label}: expected list of {minimum}..{maximum} items")
+    return value
+
+
+def _texts(value, label):
+    return [_text(v, label) for v in _items(value, label)]
+
+
+def _record(value, label, required, optional=()):
+    if not isinstance(value, dict) or set(value)-set(required)-set(optional) or set(required)-set(value):
+        raise ValueError(f"{label}: required keys {required}; optional keys {optional}")
+    return value
+
+
+def first_principles(problem, success_metric, facts, assumptions, constraints=None):
+    """Separate observations from premises and make validation gaps explicit."""
+    problem, metric = _text(problem, 'problem'), _text(success_metric, 'success_metric')
+    constraints = _texts([] if constraints is None else constraints, 'constraints')
+    observations = []
+    for i, item in enumerate(_items(facts, 'facts')):
+        item = _record(item, 'fact', ('claim', 'evidence'))
+        observations.append({'id':f'F{i+1}', 'claim':_text(item['claim'], 'claim'),
+            'evidence':_text(item['evidence'], 'evidence'), 'verification':'caller_supplied_not_independently_verified'})
+    premises, experiments = [], []
+    for i, item in enumerate(_items(assumptions, 'assumptions')):
+        item = _record(item, 'assumption', ('claim',), ('test', 'falsifier'))
+        test = _text(item['test'], 'test') if 'test' in item else None
+        falsifier = _text(item['falsifier'], 'falsifier') if 'falsifier' in item else None
+        ident = f'A{i+1}'
+        premises.append({'id':ident, 'claim':_text(item['claim'], 'claim'), 'status':'unverified'})
+        experiments.append({'assumption_id':ident, 'test':test, 'falsifier':falsifier,
+                            'ready_for_review':bool(test and falsifier)})
+    gaps = []
+    if not observations: gaps.append('No evidence supplied; do not relabel assumptions as facts.')
+    if not premises: gaps.append('No assumptions listed; check whether hidden premises were omitted.')
+    gaps += [f"{x['assumption_id']}: supply a test and explicit falsification criterion."
+             for x in experiments if not x['ready_for_review']]
+    return {'mode':'first_principles', 'problem':problem, 'success_metric':metric,
+            'observations':observations, 'assumptions':premises, 'constraints':constraints,
+            'experiments':experiments, 'gaps':gaps,
+            'rebuild_questions':['Which causal mechanism connects the observations to the goal?',
+                                 'What is the smallest experiment that distinguishes alternative explanations?',
+                                 'Can the goal be achieved without the untested premise?'],
+            'decision':'analysis_only_no_execution_approval'}
+
+
+def compound(initial, returns, contribution=0.0, fee_rate=0.0, period_label='period'):
+    """End-of-period contribution; fee applies to post-return invested balance.
+
+    All rates are decimal, not percentages. No tax, borrowing, withdrawals or
+    guaranteed returns. A -100% return destroys existing capital; later external
+    contributions can recapitalize the account but do not reverse that loss.
+    """
+    initial = _number(initial, 'initial', 0, 1e12)
+    rates = [_number(r, 'return', -1, 10) for r in _items(returns, 'returns', 1, 600)]
+    contribution = _number(contribution, 'contribution', 0, 1e12)
+    fee_rate = _number(fee_rate, 'fee_rate', 0, 1)
+    period_label = _text(period_label, 'period_label')
+    balance, no_fee, total_fees = initial, initial, 0.0
+    index, peak, max_drawdown = 1.0, 1.0, 0.0
+    path = []
+    for i, rate in enumerate(rates, 1):
+        gross = balance*(1+rate)
+        fee = gross*fee_rate
+        balance = gross-fee+contribution
+        no_fee = no_fee*(1+rate)+contribution
+        total_fees += fee
+        index *= (1+rate)*(1-fee_rate)
+        if not all(math.isfinite(x) and abs(x) <= 1e100 for x in (balance, no_fee, total_fees, index)):
+            raise ValueError('Scenario exceeds supported numeric range')
+        peak = max(peak, index)
+        drawdown = 1-index/peak
+        max_drawdown = max(max_drawdown, drawdown)
+        path.append({'period':i, 'return':rate, 'fee':fee, 'contribution':contribution, 'balance':balance})
+    paid_in = initial+len(rates)*contribution
+    geometric = math.expm1(sum(math.log1p(r)+math.log1p(-fee_rate) for r in rates)/len(rates)) if all(r>-1 for r in rates) and fee_rate<1 else -1.0
+    return {'mode':'compound', 'period_label':period_label, 'periods':len(rates),
+            'final_balance':balance, 'total_contributed':paid_in, 'net_growth':balance-paid_in,
+            'fees_paid':total_fees, 'no_fee_final_balance':no_fee, 'fee_drag':no_fee-balance,
+            'arithmetic_mean_gross_return':sum(rates)/len(rates), 'geometric_mean_net_return':geometric,
+            'flow_adjusted_max_drawdown':max_drawdown,
+            'recovery_gain_from_max_drawdown':None if max_drawdown>=1 else max_drawdown/(1-max_drawdown),
+            'path':path, 'assumptions':['Contribution is added after return and fees each period.',
+                'Drawdown uses a unit capital index excluding external contributions; zero index stays zero.',
+                'Scenarios are supplied by the caller; this is not a forecast or expected return.',
+                'No tax, inflation, margin, execution slippage or annualization.']}
+
+
+def bayesian(prior, evidence, assume_conditional_independence=False):
+    """Binary H / not-H Bayesian update in log space to avoid underflow."""
+    prior = _number(prior, 'prior', 0, 1)
+    evidence = _items(evidence, 'evidence', 1, 50)
+    if type(assume_conditional_independence) is not bool:
+        raise ValueError('assume_conditional_independence must be boolean')
+    if len(evidence)>1 and not assume_conditional_independence:
+        raise ValueError('Multiple evidence requires explicit conditional independence assumption; combine correlated evidence outside this tool')
+    log_h = math.log(prior) if prior else -math.inf
+    log_not = math.log1p(-prior) if prior<1 else -math.inf
+    steps, seen = [], set()
+    for item in evidence:
+        item = _record(item, 'evidence', ('id', 'p_given_h', 'p_given_not_h'))
+        ident = _text(item['id'], 'evidence id')
+        if ident in seen: raise ValueError('Duplicate evidence id; do not count the same observation twice')
+        seen.add(ident)
+        ph = _number(item['p_given_h'], 'p_given_h', 0, 1)
+        pn = _number(item['p_given_not_h'], 'p_given_not_h', 0, 1)
+        log_h += math.log(ph) if ph else -math.inf
+        log_not += math.log(pn) if pn else -math.inf
+        top = max(log_h, log_not)
+        if top == -math.inf:
+            raise ValueError('Evidence has zero probability under the supplied model; posterior undefined')
+        weight_h, weight_not = math.exp(log_h-top), math.exp(log_not-top)
+        posterior = weight_h/(weight_h+weight_not)
+        steps.append({'id':ident, 'p_given_h':ph, 'p_given_not_h':pn, 'posterior':posterior,
+                      'log_likelihood_ratio':math.log(ph)-math.log(pn) if ph and pn else None,
+                      'zero_likelihood':('h' if ph==0 else 'not_h') if ph==0 or pn==0 else None})
+    return {'mode':'bayesian', 'prior':prior, 'posterior':steps[-1]['posterior'], 'steps':steps,
+            'conditional_independence_assumed':len(evidence)>1,
+            'warnings':['Likelihoods and prior are caller estimates, not calibrated by this tool.',
+                        'Probability is not trade confidence, position size or permission to execute.',
+                        'Correlated evidence can create false certainty; unique IDs do not prove independence.'] +
+                       (['A prior of 0 or 1 cannot be changed by ordinary evidence.'] if prior in (0,1) else [])}
+
+
+def inversion(goal, failures):
+    """Pre-mortem checklist; severity is an ordinal caller judgment, not odds."""
+    goal = _text(goal, 'goal')
+    rows = []
+    for i, item in enumerate(_items(failures, 'failures', 1)):
+        item = _record(item, 'failure', ('outcome', 'cause', 'severity'), ('warning_sign', 'prevention', 'verification', 'stop_condition'))
+        if type(item['severity']) is not int or not 1<=item['severity']<=5:
+            raise ValueError('severity must be an ordinal integer in 1..5')
+        row = {'id':f'R{i+1}', 'outcome':_text(item['outcome'], 'outcome'),
+               'cause':_text(item['cause'], 'cause'), 'severity':item['severity']}
+        for key in ('warning_sign', 'prevention', 'verification', 'stop_condition'):
+            row[key] = _text(item[key], key) if key in item else None
+        row['missing_controls'] = [k for k in ('warning_sign', 'prevention', 'verification', 'stop_condition') if row[k] is None]
+        rows.append(row)
+    rows.sort(key=lambda r:-r['severity'])
+    return {'mode':'inversion', 'goal':goal, 'premortem_question':'Assume this goal failed. What could have caused it?',
+            'failure_register':rows, 'review_first':[r['id'] for r in rows if r['severity']>=4 or r['missing_controls']],
+            'decision':'review_required',
+            'limitations':['Causes and controls are caller-supplied, not an exhaustive risk discovery.',
+                           'Severity is ordinal. No risk probability or success score is inferred.',
+                           'A completed checklist does not certify safety; test the controls.']}
+
+
+def _obj(properties, required):
+    return {'type':'object', 'properties':properties, 'required':required, 'additionalProperties':False}
+
+TEXT = {'type':'string','minLength':1,'maxLength':2000}
+PROB = {'type':'number','minimum':0,'maximum':1}
+def _array(items, minimum=0, maximum=50):
+    return {'type':'array','items':items,'minItems':minimum,'maxItems':maximum}
+
+DEFINITIONS = [
+ {'name':'think_first_principles','description':'第一性原理：分离证据、假设、约束及可证伪实验，不认证事实',
+  'inputSchema':_obj({'problem':TEXT,'success_metric':TEXT,
+      'facts':_array(_obj({'claim':TEXT,'evidence':TEXT},['claim','evidence'])),
+      'assumptions':_array(_obj({'claim':TEXT,'test':TEXT,'falsifier':TEXT},['claim'])),
+      'constraints':_array(TEXT)},['problem','success_metric','facts','assumptions'])},
+ {'name':'think_compound','description':'复利思维：逐期收益、费用、期末投入及资金流剔除后的回撤；小数收益率0.01=1%',
+  'inputSchema':_obj({'initial':{'type':'number','minimum':0,'maximum':1e12},
+      'returns':_array({'type':'number','minimum':-1,'maximum':10},1,600),
+      'contribution':{'type':'number','minimum':0,'maximum':1e12,'default':0},
+      'fee_rate':{**PROB,'default':0},'period_label':TEXT},['initial','returns'])},
+ {'name':'think_bayesian','description':'贝叶斯：二元假设的先验与显式似然更新；多条证据必须确认条件独立假设',
+  'inputSchema':_obj({'prior':PROB,'evidence':_array(_obj({'id':TEXT,'p_given_h':PROB,'p_given_not_h':PROB},
+      ['id','p_given_h','p_given_not_h']),1),
+      'assume_conditional_independence':{'type':'boolean','default':False}},['prior','evidence'])},
+ {'name':'think_inversion','description':'逆向思维：失败预演、预警、防护、验证和停止条件；不预测成功概率',
+  'inputSchema':_obj({'goal':TEXT,'failures':_array(_obj({'outcome':TEXT,'cause':TEXT,
+      'severity':{'type':'integer','minimum':1,'maximum':5},'warning_sign':TEXT,'prevention':TEXT,
+      'verification':TEXT,'stop_condition':TEXT},['outcome','cause','severity']),1)},['goal','failures'])}
+]
+FUNCTIONS = dict(think_first_principles=first_principles, think_compound=compound,
+                 think_bayesian=bayesian, think_inversion=inversion)
+
+
+def list_tools():
+    return deepcopy(DEFINITIONS)
+
+
+def has_tool(name):
+    return isinstance(name, str) and name in FUNCTIONS
+
+
+def call(name, args=None):
+    try:
+        if not has_tool(name): raise ValueError('Unknown thinking tool')
+        if args is None: args={}
+        if not isinstance(args, dict): raise ValueError('arguments must be an object')
+        return {'ok':True, 'result':FUNCTIONS[name](**args)}
+    except (ValueError, TypeError, OverflowError) as exc:
+        return {'ok':False, 'error':str(exc)}

package/python/server.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""@arong8888/tulip-aibot-mcp 的 stdio MCP 服务器。
+
+只暴露纯离线、纯标准库的计算工具：量化指标/风险/仓位（quant_tools）、
+代理工具（agent_tools）、思维辅助（reasoning_tools）。
+不连接 MT5、不读本地文件路径之外的数据、不下单。
+协议：JSON-RPC 2.0 over stdio（每行一个请求）。
+"""
+import json
+import sys
+
+import agent_tools
+import quant_tools
+import reasoning_tools
+
+REGISTRIES = [agent_tools, quant_tools, reasoning_tools]
+SERVER_INFO = {"name": "tulip-aibot-mcp", "version": "0.1.0"}
+
+
+def tool_definitions():
+    defs = []
+    for mod in REGISTRIES:
+        defs.extend(mod.list_tools())
+    return defs
+
+
+def dispatch(name, args):
+    for mod in REGISTRIES:
+        if mod.has_tool(name):
+            fn = getattr(mod, "call_tool", None) or getattr(mod, "call")
+            return fn(name, args)
+    return {"ok": False, "error": f"未知工具: {name}"}
+
+
+def send(payload):
+    sys.stdout.write(json.dumps(payload, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def handle(req):
+    method = req.get("method", "")
+    rid = req.get("id")
+    if rid is None:
+        return  # 通知（如 notifications/initialized）：无需应答
+    try:
+        if method == "initialize":
+            result = {"protocolVersion": "2024-11-05",
+                      "capabilities": {"tools": {"listChanged": False}},
+                      "serverInfo": SERVER_INFO}
+        elif method == "tools/list":
+            result = {"tools": tool_definitions()}
+        elif method == "tools/call":
+            params = req.get("params") or {}
+            res = dispatch(params.get("name", ""), params.get("arguments") or {})
+            result = {"content": [{"type": "text",
+                                   "text": json.dumps(res, ensure_ascii=False)}]}
+            if isinstance(res, dict) and res.get("ok") is False:
+                result["isError"] = True
+        elif method == "ping":
+            result = {}
+        else:
+            send({"jsonrpc": "2.0", "id": rid,
+                  "error": {"code": -32601, "message": f"Unknown method: {method}"}})
+            return
+        send({"jsonrpc": "2.0", "id": rid, "result": result})
+    except Exception as exc:  # 服务器永不崩溃：错误转 JSON-RPC error
+        send({"jsonrpc": "2.0", "id": rid,
+              "error": {"code": -32603, "message": f"Internal error: {exc}"}})
+
+
+def main():
+    # Windows 管道默认 GBK 编码，MCP 客户端约定 UTF-8
+    sys.stdin.reconfigure(encoding="utf-8")
+    sys.stdout.reconfigure(encoding="utf-8")
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(req, dict):
+            handle(req)
+
+
+if __name__ == "__main__":
+    main()