@ljwei-stak/dsh-model-route-bot 0.66.3 → 0.67.0

package/packages/orchestration/src/native-team-tools.mjs

@@ -0,0 +1,73 @@
+/**
+ * The native MCP door for the four teammate-coordination tools.
+ *
+ * This is the independent-runtime half of the team family: it wraps the coordination
+ * service (createTeamCoordination in team-bridge.mjs) in the same handler shape the
+ * native conversation tools use (native-conversation-tools.mjs), reading names,
+ * descriptions and schemas from the ONE shared contract (team-tool-contract.mjs) so the
+ * native and SDK doors cannot drift.
+ *
+ * Authority: the calling Bot and its conversation are bound here from the Host-resolved
+ * native identity (`callerBotId`, `conversationId`) — never from the tool arguments,
+ * which parseTeamToolArgs has already refused any `botId`/`owner`/route/session key in.
+ * Every call re-runs the injected `validate()` around each awaited step, exactly as the
+ * other native doors do, so a subject, funding or credential that changed stops the call.
+ *
+ * A refusal is returned as a structured value the model can read, never a thrown crash:
+ * the model is told the coded reason and, for a durable identity it already holds, what
+ * to do next. An unknown outcome is never replayed from here.
+ */
+
+import { TEAM_TOOL_ENTRIES, TEAM_CODES, parseTeamToolArgs, projectCoordinateArgs } from './team-tool-contract.mjs'
+import { redactNativeToolValue } from './native-conversation-tools.mjs'
+
+const reference = value => typeof value === 'string' && /^[A-Za-z0-9_.:-]{1,160}$/.test(value) ? value : null
+const safeCode = code => /^[A-Z][A-Z0-9_:-]{0,95}$/.test(code ?? '') ? code : 'TEAM_CALL_FAILED'
+
+/**
+ * @param {{
+ *   service: object,                     // createTeamCoordination()
+ *   callerBotId: string,                 // Host-resolved native identity botId
+ *   conversationId?: string | null,      // Host-resolved per-work-thread conversationId
+ *   sessionId?: string | null,
+ *   validate: () => Promise<void>,       // re-check subject/funding/credential per step
+ *   redact?: (text: string) => string,
+ * }} options
+ */
+export function createNativeTeamTools({ service, callerBotId, conversationId = null, sessionId = null, validate, redact = text => text } = {}) {
+  if (!service || typeof service.coordinateBots !== 'function') throw new TypeError('NATIVE_TEAM_REQUIRES_SERVICE')
+  if (typeof callerBotId !== 'string' || !callerBotId) throw new TypeError('NATIVE_TEAM_REQUIRES_CALLER')
+  if (typeof validate !== 'function') throw new TypeError('NATIVE_TEAM_REQUIRES_VALIDATE')
+
+  const handlers = TEAM_TOOL_ENTRIES.filter(() => service.canUse(callerBotId)).map(entry => ({
+    definition: { name: entry.name, description: entry.description, inputSchema: entry.inputSchema },
+    capability: entry.capability,
+    parse: args => parseTeamToolArgs(entry.name, args),
+    render: value => ({ content: [{ type: 'text', text: JSON.stringify(redactNativeToolValue(value, redact)) }], ...(value?.error ? { isError: true } : {}) }),
+    async execute(args, context) {
+      const turn = context.context
+      if (!turn?.turnId || !turn.callId || !context.signal) throw new Error('NATIVE_TOOL_TURN_REQUIRED')
+      const check = async () => { context.signal.throwIfAborted(); await validate(); context.signal.throwIfAborted(); if (!service.canUse(callerBotId)) throw Object.assign(new Error('TEAM_CALLER_NOT_AUTHORIZED'), { code: 'TEAM_CALLER_NOT_AUTHORIZED' }) }
+      try {
+        await check()
+        const request = { callerBotId, conversationId, sessionId, turnId: turn.turnId, callId: turn.callId, signal: context.signal }
+        let value
+        if (entry.method === 'coordinateBots') {
+          value = await service.coordinateBots({ ...request, args: projectCoordinateArgs(args) })
+        }
+        else if (entry.method === 'assignmentStatus') value = await service.assignmentStatus({ ...request, args })
+        else if (entry.method === 'listBots') value = await service.listBots(request)
+        else value = await service.listThreads(request)
+        await check()
+        service.validateResult?.(request, value)
+        return redactNativeToolValue(value, redact)
+      } catch (error) {
+        try { await check() } catch (changed) { error = changed }
+        const coded = safeCode(error?.code)
+        return { error: { code: coded, message: redact(String(error?.message ?? error)) } }
+      }
+    },
+  }))
+
+  return { tools: handlers.map(handler => handler.definition.name), handlers }
+}

package/packages/orchestration/src/pairing-invite.mjs

@@ -0,0 +1,37 @@
+const fail = code => { throw Object.assign(new Error(code), { code }) }
+const id = value => typeof value === 'string' && /^[-A-Za-z0-9_.]{1,128}$/.test(value)
+const object = (value, allowed) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !allowed.includes(key))) fail('PAIRING_INVITE_INVALID')
+}
+const list = value => {
+  if (!Array.isArray(value) || value.length > 64 || value.some(item => !id(item)) || new Set(value).size !== value.length) fail('PAIRING_INVITE_INVALID')
+  return [...value].sort()
+}
+
+/** Shared browser/Host shape validation. Cryptographic point validation belongs to the Host transport. */
+export function parseSecureInvite(input) {
+  if (typeof input === 'string') {
+    if (input.length > 16384) fail('PAIRING_INVITE_INVALID')
+    try { input = JSON.parse(input) } catch { fail('PAIRING_INVITE_INVALID') }
+  }
+  object(input, ['format','version','inviteId','machineId','clientId','name','endpoint','expiresAt','token','code','transport','ceiling'])
+  if (input.format !== 'dsh-pairing-invite' || input.version !== 2) fail('PAIRING_VERSION_UNSUPPORTED')
+  if (![input.inviteId,input.machineId,input.clientId].every(id) || !Number.isSafeInteger(input.expiresAt) || input.expiresAt <= 0
+    || typeof input.name !== 'string' || !input.name || input.name.length > 128 || /[\u0000-\u001f\u007f]/.test(input.name)
+    || typeof input.token !== 'string' || !/^dsh_pair_[A-Za-z0-9_-]{43}$/.test(input.token)
+    || input.code !== undefined && (typeof input.code !== 'string' || !/^\d{6}$/.test(input.code))) fail('PAIRING_INVITE_INVALID')
+  let endpoint
+  try { endpoint = new URL(input.endpoint) } catch { fail('PAIRING_INVITE_INVALID') }
+  if (!['http:','https:'].includes(endpoint.protocol) || endpoint.username || endpoint.password || endpoint.pathname !== '/' || endpoint.search || endpoint.hash || endpoint.href.length > 1024) fail('PAIRING_INVITE_INVALID')
+  object(input.transport, ['kind','publicKey','fingerprint'])
+  if (input.transport.kind !== 'noise-v1' || typeof input.transport.publicKey !== 'string' || !/^[A-Za-z0-9_-]{87}$/.test(input.transport.publicKey)
+    || typeof input.transport.fingerprint !== 'string' || !/^[a-f0-9]{64}$/.test(input.transport.fingerprint)) fail('PAIRING_TRANSPORT_INVALID')
+  object(input.ceiling, ['botIds','hostManagedBots','roots','tools'])
+  if (input.ceiling.hostManagedBots !== undefined && typeof input.ceiling.hostManagedBots !== 'boolean') fail('PAIRING_INVITE_INVALID')
+  const ceiling = { botIds: list(input.ceiling.botIds ?? []), roots: list(input.ceiling.roots), tools: list(input.ceiling.tools),
+    ...(input.ceiling.hostManagedBots === true ? { hostManagedBots: true } : {}) }
+  if (!ceiling.roots.length || !ceiling.tools.includes('machine_ping') || !ceiling.hostManagedBots && !ceiling.botIds.length) fail('PAIRING_INVITE_INVALID')
+  return { format: input.format, version: 2, inviteId: input.inviteId, machineId: input.machineId, clientId: input.clientId,
+    name: input.name, endpoint: endpoint.origin, expiresAt: input.expiresAt, token: input.token, ...(input.code ? { code: input.code } : {}),
+    transport: { ...input.transport }, ceiling }
+}