octoflow-core 1.0.0

package/dist/runtime/orchestration/pack/pack-bootstrap.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/pack/pack-bootstrap.ts"],
+  "sourcesContent": ["import { existsSync, readFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nimport type { PackOptions } from './types.js';\n\nexport function clonePackOptionsSnapshot(options: PackOptions): PackOptions {\n  const snapshot: PackOptions = {\n    ...options,\n    workers: options.workers.map((worker) => ({ ...worker })),\n  };\n  if (options.shared) {\n    snapshot.shared = { ...options.shared };\n    if (options.shared.plugins) {\n      snapshot.shared.plugins = [...options.shared.plugins];\n    }\n    if (options.shared.protocol) {\n      snapshot.shared.protocol = [...options.shared.protocol];\n    }\n    if (options.shared.tools) {\n      snapshot.shared.tools = { ...options.shared.tools };\n    }\n  }\n  if (options.leader) {\n    snapshot.leader = { ...options.leader };\n    if (options.leader.plugins) {\n      snapshot.leader.plugins = [...options.leader.plugins];\n    }\n    if (options.leader.priority) {\n      snapshot.leader.priority = [...options.leader.priority];\n    }\n    if (options.leader.tools) {\n      snapshot.leader.tools = { ...options.leader.tools };\n    }\n  }\n  return snapshot;\n}\n\nexport function findPromptsDir(startDir: string): string | undefined {\n  let current = startDir;\n  while (true) {\n    const candidate = join(current, 'prompts');\n    if (existsSync(join(candidate, 'LEADER_TECHNIQUES.md'))) {\n      return candidate;\n    }\n    const parent = dirname(current);\n    if (parent === current) return undefined;\n    current = parent;\n  }\n}\n\nexport let SUPERVISOR_PLAYBOOK = '';\n/** @internal */\nexport let WORKER_PLAYBOOK = '';\n\ntry {\n  const currentDir = dirname(fileURLToPath(import.meta.url));\n  const promptsDir = findPromptsDir(currentDir);\n  if (promptsDir) {\n    SUPERVISOR_PLAYBOOK = readFileSync(\n      join(promptsDir, 'LEADER_TECHNIQUES.md'),\n      'utf8'\n    );\n    WORKER_PLAYBOOK = readFileSync(\n      join(promptsDir, 'AGENT_TECHNIQUES.md'),\n      'utf8'\n    );\n  }\n} catch {\n  // Playbooks not available (e.g., running from npm without prompts dir)\n}\n"],
+  "mappings": "AAAA,SAAS,YAAY,oBAAoB;AACzC,SAAS,SAAS,YAAY;AAC9B,SAAS,qBAAqB;AAIvB,SAAS,yBAAyB,SAAmC;AAC1E,QAAM,WAAwB;AAAA,IAC5B,GAAG;AAAA,IACH,SAAS,QAAQ,QAAQ,IAAI,CAAC,YAAY,EAAE,GAAG,OAAO,EAAE;AAAA,EAC1D;AACA,MAAI,QAAQ,QAAQ;AAClB,aAAS,SAAS,EAAE,GAAG,QAAQ,OAAO;AACtC,QAAI,QAAQ,OAAO,SAAS;AAC1B,eAAS,OAAO,UAAU,CAAC,GAAG,QAAQ,OAAO,OAAO;AAAA,IACtD;AACA,QAAI,QAAQ,OAAO,UAAU;AAC3B,eAAS,OAAO,WAAW,CAAC,GAAG,QAAQ,OAAO,QAAQ;AAAA,IACxD;AACA,QAAI,QAAQ,OAAO,OAAO;AACxB,eAAS,OAAO,QAAQ,EAAE,GAAG,QAAQ,OAAO,MAAM;AAAA,IACpD;AAAA,EACF;AACA,MAAI,QAAQ,QAAQ;AAClB,aAAS,SAAS,EAAE,GAAG,QAAQ,OAAO;AACtC,QAAI,QAAQ,OAAO,SAAS;AAC1B,eAAS,OAAO,UAAU,CAAC,GAAG,QAAQ,OAAO,OAAO;AAAA,IACtD;AACA,QAAI,QAAQ,OAAO,UAAU;AAC3B,eAAS,OAAO,WAAW,CAAC,GAAG,QAAQ,OAAO,QAAQ;AAAA,IACxD;AACA,QAAI,QAAQ,OAAO,OAAO;AACxB,eAAS,OAAO,QAAQ,EAAE,GAAG,QAAQ,OAAO,MAAM;AAAA,IACpD;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,eAAe,UAAsC;AACnE,MAAI,UAAU;AACd,SAAO,MAAM;AACX,UAAM,YAAY,KAAK,SAAS,SAAS;AACzC,QAAI,WAAW,KAAK,WAAW,sBAAsB,CAAC,GAAG;AACvD,aAAO;AAAA,IACT;AACA,UAAM,SAAS,QAAQ,OAAO;AAC9B,QAAI,WAAW,QAAS,QAAO;AAC/B,cAAU;AAAA,EACZ;AACF;AAEO,IAAI,sBAAsB;AAE1B,IAAI,kBAAkB;AAE7B,IAAI;AACF,QAAM,aAAa,QAAQ,cAAc,YAAY,GAAG,CAAC;AACzD,QAAM,aAAa,eAAe,UAAU;AAC5C,MAAI,YAAY;AACd,0BAAsB;AAAA,MACpB,KAAK,YAAY,sBAAsB;AAAA,MACvC;AAAA,IACF;AACA,sBAAkB;AAAA,MAChB,KAAK,YAAY,qBAAqB;AAAA,MACtC;AAAA,IACF;AAAA,EACF;AACF,QAAQ;AAER;",
+  "names": []
+}

package/dist/runtime/orchestration/pack/pack-delegation-loop.d.ts

@@ -0,0 +1,28 @@
+import type { BridgeSendMessageParams, BridgeSendResult } from '../../../domain/bridge-api.js';
+import type { BridgeEventEmitter } from '../../bridge/events.js';
+import type { BridgeWithFabric } from '../../bridge/fabric-bridge-types.js';
+import type { DelegationDriver, DelegationEntry, PackOptions, PackResult, PackSendParams } from './types.js';
+interface PackDelegationLoopDeps {
+    driver: DelegationDriver;
+    isClosed: () => boolean;
+    options: PackOptions;
+    packId: string;
+    runDispatch: (entries: DelegationEntry[], contextId: string, leaderTaskId: string | undefined, forwardedParams: Pick<BridgeSendMessageParams, 'approvalMode' | 'onError' | 'onRetry' | 'onToolApproval' | 'tenant' | 'timeoutMs'>) => Promise<{
+        results: Array<{
+            name: string;
+            result: BridgeSendResult;
+        }>;
+        droppedWorkers: string[];
+    }>;
+    runLeader: (input: BridgeSendMessageParams) => Promise<BridgeSendResult>;
+    leaderFabric: () => Partial<BridgeWithFabric>['fabric'];
+    events?: BridgeEventEmitter;
+}
+/**
+ * Leader↔worker delegation loop extracted from `Pack.sendMessage`. Runs
+ * leader turns, parses delegation manifests, dispatches rounds via `deps`,
+ * and returns a final `PackResult`.
+ */
+export declare function runPackDelegationLoop(params: PackSendParams, deps: PackDelegationLoopDeps): Promise<PackResult>;
+export {};
+//# sourceMappingURL=pack-delegation-loop.d.ts.map

package/dist/runtime/orchestration/pack/pack-delegation-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-delegation-loop.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/pack/pack-delegation-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAM5E,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EAEf,WAAW,EACX,UAAU,EACV,cAAc,EACf,MAAM,YAAY,CAAC;AAGpB,UAAU,sBAAsB;IAC9B,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,CACX,OAAO,EAAE,eAAe,EAAE,EAC1B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,eAAe,EAAE,IAAI,CACnB,uBAAuB,EACrB,cAAc,GACd,SAAS,GACT,SAAS,GACT,gBAAgB,GAChB,QAAQ,GACR,WAAW,CACd,KACE,OAAO,CAAC;QACX,OAAO,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,gBAAgB,CAAA;SAAE,CAAC,CAAC;QAC3D,cAAc,EAAE,MAAM,EAAE,CAAC;KAC1B,CAAC,CAAC;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACzE,YAAY,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAC;IACxD,MAAM,CAAC,EAAE,kBAAkB,CAAC;CAC7B;AAuBD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,UAAU,CAAC,CAqHrB"}

package/dist/runtime/orchestration/pack/pack-delegation-loop.js

@@ -0,0 +1,115 @@
+import { extractText } from "../../../utils/extract-text.js";
+import {
+  buildLeaderFollowUp,
+  buildPackResult,
+  readFabricFollowUpSummary
+} from "./dispatch.js";
+import { PackCancelledError } from "./types.js";
+function toWorkerForwardedParams(params) {
+  return {
+    approvalMode: params.approvalMode,
+    onError: params.onError,
+    onRetry: params.onRetry,
+    onToolApproval: params.onToolApproval,
+    tenant: params.tenant,
+    timeoutMs: params.timeoutMs
+  };
+}
+async function runPackDelegationLoop(params, deps) {
+  const {
+    driver,
+    isClosed,
+    options,
+    packId,
+    runDispatch,
+    runLeader,
+    leaderFabric,
+    events
+  } = deps;
+  const contextId = params.contextId ?? crypto.randomUUID();
+  const maxRounds = options.maxDelegationRounds ?? 3;
+  const maxRetries = options.maxParseRetries ?? 1;
+  const totalTimeoutMs = options.delegationTimeoutMs;
+  const startTime = Date.now();
+  const allRounds = [];
+  let round = 0;
+  let retryCount = 0;
+  let leaderTaskId;
+  let leaderInput = {
+    ...params,
+    message: params.message,
+    contextId
+  };
+  while (round < maxRounds) {
+    if (isClosed()) throw new PackCancelledError(packId);
+    if (totalTimeoutMs && Date.now() - startTime >= totalTimeoutMs) {
+      const lastResult = await runLeader(leaderInput);
+      return buildPackResult(lastResult, allRounds, { timedOut: true });
+    }
+    const leaderResult = await runLeader(leaderInput);
+    if (leaderResult.kind === "task") leaderTaskId = leaderResult.taskId;
+    const responseText = extractText(leaderResult);
+    const parseResult = driver.parse(responseText);
+    if (parseResult.kind === "malformed" && retryCount < maxRetries) {
+      retryCount++;
+      leaderInput = {
+        ...params,
+        message: driver.buildCorrectionPrompt(
+          parseResult.raw,
+          parseResult.error
+        ),
+        contextId
+      };
+      continue;
+    }
+    retryCount = 0;
+    if (parseResult.kind !== "ok" || parseResult.entries.length === 0) {
+      const parseExhausted = parseResult.kind === "malformed";
+      return buildPackResult(leaderResult, allRounds, { parseExhausted });
+    }
+    round++;
+    const dispatch = await runDispatch(
+      parseResult.entries,
+      contextId,
+      leaderTaskId,
+      toWorkerForwardedParams(params)
+    );
+    allRounds.push({
+      round,
+      leaderReasoning: responseText,
+      delegations: parseResult.entries,
+      workerResults: dispatch.results,
+      droppedWorkers: dispatch.droppedWorkers.length > 0 ? dispatch.droppedWorkers : void 0
+    });
+    const fabricSummary = await readFabricFollowUpSummary(leaderFabric());
+    leaderInput = buildLeaderFollowUp(
+      dispatch.results,
+      round,
+      contextId,
+      options,
+      dispatch.droppedWorkers,
+      fabricSummary,
+      events,
+      packId
+    );
+  }
+  const remaining = totalTimeoutMs ? Math.max(0, totalTimeoutMs - (Date.now() - startTime)) : void 0;
+  const synthesisPromise = runLeader({
+    message: `Maximum delegation rounds (${maxRounds}) reached. Please synthesize a final answer from the worker results above.`,
+    contextId
+  });
+  const finalResult = remaining !== void 0 ? await Promise.race([
+    synthesisPromise,
+    new Promise(
+      (_, reject) => setTimeout(
+        () => reject(new Error("Pack synthesis timed out")),
+        remaining
+      )
+    )
+  ]) : await synthesisPromise;
+  return buildPackResult(finalResult, allRounds, { maxRoundsReached: true });
+}
+export {
+  runPackDelegationLoop
+};
+//# sourceMappingURL=pack-delegation-loop.js.map

package/dist/runtime/orchestration/pack/pack-delegation-loop.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/pack/pack-delegation-loop.ts"],
+  "sourcesContent": ["import type {\n  BridgeSendMessageParams,\n  BridgeSendResult,\n} from '../../../domain/bridge-api.js';\nimport { extractText } from '../../../utils/extract-text.js';\nimport type { BridgeEventEmitter } from '../../bridge/events.js';\nimport type { BridgeWithFabric } from '../../bridge/fabric-bridge-types.js';\nimport {\n  buildLeaderFollowUp,\n  buildPackResult,\n  readFabricFollowUpSummary,\n} from './dispatch.js';\nimport type {\n  DelegationDriver,\n  DelegationEntry,\n  DelegationRoundRecord,\n  PackOptions,\n  PackResult,\n  PackSendParams,\n} from './types.js';\nimport { PackCancelledError } from './types.js';\n\ninterface PackDelegationLoopDeps {\n  driver: DelegationDriver;\n  isClosed: () => boolean;\n  options: PackOptions;\n  packId: string;\n  runDispatch: (\n    entries: DelegationEntry[],\n    contextId: string,\n    leaderTaskId: string | undefined,\n    forwardedParams: Pick<\n      BridgeSendMessageParams,\n      | 'approvalMode'\n      | 'onError'\n      | 'onRetry'\n      | 'onToolApproval'\n      | 'tenant'\n      | 'timeoutMs'\n    >\n  ) => Promise<{\n    results: Array<{ name: string; result: BridgeSendResult }>;\n    droppedWorkers: string[];\n  }>;\n  runLeader: (input: BridgeSendMessageParams) => Promise<BridgeSendResult>;\n  leaderFabric: () => Partial<BridgeWithFabric>['fabric'];\n  events?: BridgeEventEmitter;\n}\n\nfunction toWorkerForwardedParams(\n  params: PackSendParams\n): Pick<\n  BridgeSendMessageParams,\n  | 'approvalMode'\n  | 'onError'\n  | 'onRetry'\n  | 'onToolApproval'\n  | 'tenant'\n  | 'timeoutMs'\n> {\n  return {\n    approvalMode: params.approvalMode,\n    onError: params.onError,\n    onRetry: params.onRetry,\n    onToolApproval: params.onToolApproval,\n    tenant: params.tenant,\n    timeoutMs: params.timeoutMs,\n  };\n}\n\n/**\n * Leader\u2194worker delegation loop extracted from `Pack.sendMessage`. Runs\n * leader turns, parses delegation manifests, dispatches rounds via `deps`,\n * and returns a final `PackResult`.\n */\nexport async function runPackDelegationLoop(\n  params: PackSendParams,\n  deps: PackDelegationLoopDeps\n): Promise<PackResult> {\n  const {\n    driver,\n    isClosed,\n    options,\n    packId,\n    runDispatch,\n    runLeader,\n    leaderFabric,\n    events,\n  } = deps;\n  const contextId = params.contextId ?? crypto.randomUUID();\n  const maxRounds = options.maxDelegationRounds ?? 3;\n  const maxRetries = options.maxParseRetries ?? 1;\n  const totalTimeoutMs = options.delegationTimeoutMs;\n  const startTime = Date.now();\n  const allRounds: DelegationRoundRecord[] = [];\n\n  let round = 0;\n  let retryCount = 0;\n  let leaderTaskId: string | undefined;\n  let leaderInput: BridgeSendMessageParams = {\n    ...params,\n    message: params.message,\n    contextId,\n  };\n\n  while (round < maxRounds) {\n    if (isClosed()) throw new PackCancelledError(packId);\n\n    if (totalTimeoutMs && Date.now() - startTime >= totalTimeoutMs) {\n      const lastResult = await runLeader(leaderInput);\n      return buildPackResult(lastResult, allRounds, { timedOut: true });\n    }\n\n    const leaderResult = await runLeader(leaderInput);\n    if (leaderResult.kind === 'task') leaderTaskId = leaderResult.taskId;\n\n    const responseText = extractText(leaderResult);\n    const parseResult = driver.parse(responseText);\n\n    if (parseResult.kind === 'malformed' && retryCount < maxRetries) {\n      retryCount++;\n      leaderInput = {\n        ...params,\n        message: driver.buildCorrectionPrompt(\n          parseResult.raw,\n          parseResult.error\n        ),\n        contextId,\n      };\n      continue;\n    }\n\n    retryCount = 0;\n\n    if (parseResult.kind !== 'ok' || parseResult.entries.length === 0) {\n      const parseExhausted = parseResult.kind === 'malformed';\n      return buildPackResult(leaderResult, allRounds, { parseExhausted });\n    }\n\n    round++;\n\n    const dispatch = await runDispatch(\n      parseResult.entries,\n      contextId,\n      leaderTaskId,\n      toWorkerForwardedParams(params)\n    );\n\n    allRounds.push({\n      round,\n      leaderReasoning: responseText,\n      delegations: parseResult.entries,\n      workerResults: dispatch.results,\n      droppedWorkers:\n        dispatch.droppedWorkers.length > 0\n          ? dispatch.droppedWorkers\n          : undefined,\n    });\n\n    const fabricSummary = await readFabricFollowUpSummary(leaderFabric());\n    leaderInput = buildLeaderFollowUp(\n      dispatch.results,\n      round,\n      contextId,\n      options,\n      dispatch.droppedWorkers,\n      fabricSummary,\n      events,\n      packId\n    );\n  }\n\n  const remaining = totalTimeoutMs\n    ? Math.max(0, totalTimeoutMs - (Date.now() - startTime))\n    : undefined;\n\n  const synthesisPromise = runLeader({\n    message: `Maximum delegation rounds (${maxRounds}) reached. Please synthesize a final answer from the worker results above.`,\n    contextId,\n  });\n\n  const finalResult =\n    remaining !== undefined\n      ? await Promise.race([\n          synthesisPromise,\n          new Promise<never>((_, reject) =>\n            setTimeout(\n              () => reject(new Error('Pack synthesis timed out')),\n              remaining\n            )\n          ),\n        ])\n      : await synthesisPromise;\n\n  return buildPackResult(finalResult, allRounds, { maxRoundsReached: true });\n}\n"],
+  "mappings": "AAIA,SAAS,mBAAmB;AAG5B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AASP,SAAS,0BAA0B;AA6BnC,SAAS,wBACP,QASA;AACA,SAAO;AAAA,IACL,cAAc,OAAO;AAAA,IACrB,SAAS,OAAO;AAAA,IAChB,SAAS,OAAO;AAAA,IAChB,gBAAgB,OAAO;AAAA,IACvB,QAAQ,OAAO;AAAA,IACf,WAAW,OAAO;AAAA,EACpB;AACF;AAOA,eAAsB,sBACpB,QACA,MACqB;AACrB,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,YAAY,OAAO,aAAa,OAAO,WAAW;AACxD,QAAM,YAAY,QAAQ,uBAAuB;AACjD,QAAM,aAAa,QAAQ,mBAAmB;AAC9C,QAAM,iBAAiB,QAAQ;AAC/B,QAAM,YAAY,KAAK,IAAI;AAC3B,QAAM,YAAqC,CAAC;AAE5C,MAAI,QAAQ;AACZ,MAAI,aAAa;AACjB,MAAI;AACJ,MAAI,cAAuC;AAAA,IACzC,GAAG;AAAA,IACH,SAAS,OAAO;AAAA,IAChB;AAAA,EACF;AAEA,SAAO,QAAQ,WAAW;AACxB,QAAI,SAAS,EAAG,OAAM,IAAI,mBAAmB,MAAM;AAEnD,QAAI,kBAAkB,KAAK,IAAI,IAAI,aAAa,gBAAgB;AAC9D,YAAM,aAAa,MAAM,UAAU,WAAW;AAC9C,aAAO,gBAAgB,YAAY,WAAW,EAAE,UAAU,KAAK,CAAC;AAAA,IAClE;AAEA,UAAM,eAAe,MAAM,UAAU,WAAW;AAChD,QAAI,aAAa,SAAS,OAAQ,gBAAe,aAAa;AAE9D,UAAM,eAAe,YAAY,YAAY;AAC7C,UAAM,cAAc,OAAO,MAAM,YAAY;AAE7C,QAAI,YAAY,SAAS,eAAe,aAAa,YAAY;AAC/D;AACA,oBAAc;AAAA,QACZ,GAAG;AAAA,QACH,SAAS,OAAO;AAAA,UACd,YAAY;AAAA,UACZ,YAAY;AAAA,QACd;AAAA,QACA;AAAA,MACF;AACA;AAAA,IACF;AAEA,iBAAa;AAEb,QAAI,YAAY,SAAS,QAAQ,YAAY,QAAQ,WAAW,GAAG;AACjE,YAAM,iBAAiB,YAAY,SAAS;AAC5C,aAAO,gBAAgB,cAAc,WAAW,EAAE,eAAe,CAAC;AAAA,IACpE;AAEA;AAEA,UAAM,WAAW,MAAM;AAAA,MACrB,YAAY;AAAA,MACZ;AAAA,MACA;AAAA,MACA,wBAAwB,MAAM;AAAA,IAChC;AAEA,cAAU,KAAK;AAAA,MACb;AAAA,MACA,iBAAiB;AAAA,MACjB,aAAa,YAAY;AAAA,MACzB,eAAe,SAAS;AAAA,MACxB,gBACE,SAAS,eAAe,SAAS,IAC7B,SAAS,iBACT;AAAA,IACR,CAAC;AAED,UAAM,gBAAgB,MAAM,0BAA0B,aAAa,CAAC;AACpE,kBAAc;AAAA,MACZ,SAAS;AAAA,MACT;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,MACT;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,YAAY,iBACd,KAAK,IAAI,GAAG,kBAAkB,KAAK,IAAI,IAAI,UAAU,IACrD;AAEJ,QAAM,mBAAmB,UAAU;AAAA,IACjC,SAAS,8BAA8B,SAAS;AAAA,IAChD;AAAA,EACF,CAAC;AAED,QAAM,cACJ,cAAc,SACV,MAAM,QAAQ,KAAK;AAAA,IACjB;AAAA,IACA,IAAI;AAAA,MAAe,CAAC,GAAG,WACrB;AAAA,QACE,MAAM,OAAO,IAAI,MAAM,0BAA0B,CAAC;AAAA,QAClD;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC,IACD,MAAM;AAEZ,SAAO,gBAAgB,aAAa,WAAW,EAAE,kBAAkB,KAAK,CAAC;AAC3E;",
+  "names": []
+}

package/dist/runtime/orchestration/pack/pack-mcp-types.d.ts

@@ -0,0 +1,21 @@
+export type McpServerTransport = {
+    type: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+} | {
+    type: 'streamable-http';
+    url: string;
+    headers?: Record<string, string>;
+};
+export interface McpServerConfig {
+    name: string;
+    transport: McpServerTransport;
+}
+export interface PackToolsConfig {
+    servers?: McpServerConfig[];
+    allowedTools?: string[];
+    maxToolCallsPerTurn?: number;
+    toolTimeoutMs?: number;
+}
+//# sourceMappingURL=pack-mcp-types.d.ts.map

package/dist/runtime/orchestration/pack/pack-mcp-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-mcp-types.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/pack/pack-mcp-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAC1B;IACE,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B,GACD;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC;AAE/E,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,kBAAkB,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/runtime/orchestration/pack/pack-mcp-types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=pack-mcp-types.js.map

package/dist/runtime/orchestration/pack/pack-mcp-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/runtime/orchestration/pack/pack-mesh.d.ts

@@ -0,0 +1,81 @@
+import type { TopicChannel } from '../../bridge/topic-channel.js';
+import type { JsonValue } from '../../bridge/topic-types.js';
+export interface MeshEntry {
+    packId: string;
+    capabilities: string[];
+    metadata: Record<string, unknown>;
+}
+export interface RemoteMeshEntry extends MeshEntry {
+    url: string;
+    apiKey?: string;
+}
+export interface MeshPresenceEvent {
+    packId: string;
+    status: 'online' | 'offline';
+    capabilities: string[];
+    timestamp: number;
+}
+export interface MeshDeliveryErrorEvent {
+    targetPackId: string;
+    messageId: string;
+    from: string;
+    to: string;
+    error: {
+        name: string;
+        message: string;
+    };
+    timestamp: number;
+}
+export interface MeshMessage {
+    id: string;
+    from: string;
+    to: string;
+    payload: JsonValue;
+    replyTo?: string;
+    timestamp: number;
+}
+export interface MeshRequestOptions {
+    timeoutMs?: number;
+}
+type MessageHandler = (msg: MeshMessage) => void;
+/**
+ * PackMesh — first-class pack-to-pack communication runtime.
+ *
+ * Provides: registration, discovery, targeted send, broadcast,
+ * request/reply, and presence notifications — all via the mesh.* TopicChannel prefix.
+ */
+export declare class PackMesh {
+    private readonly channel;
+    private readonly packs;
+    private readonly remotePacks;
+    private readonly handlers;
+    private readonly subscriptions;
+    private closed;
+    private msgCounter;
+    constructor(channel: TopicChannel);
+    register(entry: MeshEntry): void;
+    registerRemote(entry: RemoteMeshEntry): void;
+    unregister(packId: string): void;
+    list(): MeshEntry[];
+    discover(capability: string): MeshEntry[];
+    onMessage(packId: string, handler: MessageHandler): () => void;
+    send(from: string, to: string, payload: JsonValue): MeshMessage;
+    broadcast(from: string, payload: JsonValue): void;
+    /**
+     * Multicast — targeted fan-out to every pack matching a capability, excluding sender.
+     * Returns one MeshMessage per recipient. Empty subset returns [] without throwing.
+     * Each message carries its own concrete `to: packId` (not '*'), so recipients see
+     * a targeted delivery indistinguishable from {@link send}.
+     */
+    multicast(from: string, capability: string, payload: JsonValue): MeshMessage[];
+    request(from: string, to: string, payload: JsonValue, options?: MeshRequestOptions): Promise<MeshMessage>;
+    reply(original: MeshMessage, payload: JsonValue): MeshMessage;
+    close(): void;
+    private deliverToTarget;
+    private emitDeliveryError;
+    private emitPresence;
+    private assertOpen;
+    private assertRegistered;
+}
+export {};
+//# sourceMappingURL=pack-mesh.d.ts.map

package/dist/runtime/orchestration/pack/pack-mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-mesh.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/pack/pack-mesh.ts"],"names":[],"mappings":"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"}

package/dist/runtime/orchestration/pack/pack-mesh.js

@@ -0,0 +1,324 @@
+import { A2AClient } from "../../../adapters/transport/client.js";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function meshMessageFromJson(value) {
+  if (!isRecord(value)) return null;
+  const { id, from, to, payload, timestamp, replyTo } = value;
+  if (typeof id !== "string" || typeof from !== "string" || typeof to !== "string" || payload === void 0 || typeof timestamp !== "number") {
+    return null;
+  }
+  return {
+    id,
+    from,
+    to,
+    payload,
+    timestamp,
+    ...typeof replyTo === "string" ? { replyTo } : {}
+  };
+}
+function meshMessageToJson(message) {
+  return {
+    id: message.id,
+    from: message.from,
+    to: message.to,
+    payload: message.payload,
+    timestamp: message.timestamp,
+    ...message.replyTo ? { replyTo: message.replyTo } : {}
+  };
+}
+function deliveryErrorToJson(event) {
+  return {
+    targetPackId: event.targetPackId,
+    messageId: event.messageId,
+    from: event.from,
+    to: event.to,
+    error: { name: event.error.name, message: event.error.message },
+    timestamp: event.timestamp
+  };
+}
+function presenceToJson(event) {
+  return {
+    packId: event.packId,
+    status: event.status,
+    capabilities: [...event.capabilities],
+    timestamp: event.timestamp
+  };
+}
+const MESH_EMIT = { publisher: "mesh" };
+function generateMeshMsgId(from, to, counter) {
+  return `mesh-${from}-${to}-${counter}-${Date.now()}`;
+}
+function summarizeError(error) {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message };
+  }
+  return { name: "Error", message: String(error) };
+}
+class PackMesh {
+  constructor(channel) {
+    this.channel = channel;
+    const unsub = this.channel.subscribePrefix(
+      "mesh.msg.",
+      (event) => {
+        const msg = meshMessageFromJson(event.payload);
+        if (!msg) return;
+        const targetFromTopic = event.topic.slice("mesh.msg.".length);
+        this.deliverToTarget(targetFromTopic, msg);
+      }
+    );
+    this.subscriptions.push(unsub);
+  }
+  channel;
+  packs = /* @__PURE__ */ new Map();
+  remotePacks = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  subscriptions = [];
+  closed = false;
+  msgCounter = 0;
+  register(entry) {
+    this.assertOpen();
+    if (this.packs.has(entry.packId)) {
+      throw new Error(`PackMesh: pack "${entry.packId}" is already registered`);
+    }
+    this.packs.set(entry.packId, entry);
+    this.emitPresence(entry.packId, "online", entry.capabilities);
+  }
+  registerRemote(entry) {
+    this.assertOpen();
+    if (this.packs.has(entry.packId)) {
+      throw new Error(`PackMesh: pack "${entry.packId}" is already registered`);
+    }
+    const clientOpts = { url: entry.url };
+    if (entry.apiKey) {
+      clientOpts.apiKey = entry.apiKey;
+    }
+    this.remotePacks.set(entry.packId, new A2AClient(clientOpts));
+    this.packs.set(entry.packId, entry);
+    this.emitPresence(entry.packId, "online", entry.capabilities);
+  }
+  unregister(packId) {
+    this.assertOpen();
+    const entry = this.packs.get(packId);
+    if (!entry) {
+      throw new Error(`PackMesh: pack "${packId}" is not registered`);
+    }
+    this.packs.delete(packId);
+    this.handlers.delete(packId);
+    this.remotePacks.delete(packId);
+    this.emitPresence(packId, "offline", entry.capabilities);
+  }
+  list() {
+    return [...this.packs.values()];
+  }
+  discover(capability) {
+    return [...this.packs.values()].filter(
+      (e) => e.capabilities.includes(capability)
+    );
+  }
+  onMessage(packId, handler) {
+    let handlers = this.handlers.get(packId);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.handlers.set(packId, handlers);
+    }
+    handlers.add(handler);
+    const captured = handlers;
+    return () => {
+      captured.delete(handler);
+    };
+  }
+  send(from, to, payload) {
+    this.assertOpen();
+    this.assertRegistered(from);
+    this.assertRegistered(to);
+    const msg = {
+      id: generateMeshMsgId(from, to, ++this.msgCounter),
+      from,
+      to,
+      payload,
+      timestamp: Date.now()
+    };
+    this.channel.emit(`mesh.msg.${to}`, meshMessageToJson(msg), MESH_EMIT);
+    return msg;
+  }
+  broadcast(from, payload) {
+    this.assertOpen();
+    this.assertRegistered(from);
+    const msg = {
+      id: generateMeshMsgId(from, "*", ++this.msgCounter),
+      from,
+      to: "*",
+      payload,
+      timestamp: Date.now()
+    };
+    const targets = [...this.packs.keys()].filter((id) => id !== from);
+    for (const target of targets) {
+      this.channel.emit(
+        `mesh.msg.${target}`,
+        meshMessageToJson(msg),
+        MESH_EMIT
+      );
+    }
+  }
+  /**
+   * Multicast — targeted fan-out to every pack matching a capability, excluding sender.
+   * Returns one MeshMessage per recipient. Empty subset returns [] without throwing.
+   * Each message carries its own concrete `to: packId` (not '*'), so recipients see
+   * a targeted delivery indistinguishable from {@link send}.
+   */
+  multicast(from, capability, payload) {
+    this.assertOpen();
+    this.assertRegistered(from);
+    const recipients = [...this.packs.values()].filter(
+      (entry) => entry.packId !== from && entry.capabilities.includes(capability)
+    );
+    const messages = [];
+    for (const recipient of recipients) {
+      const msg = {
+        id: generateMeshMsgId(from, recipient.packId, ++this.msgCounter),
+        from,
+        to: recipient.packId,
+        payload,
+        timestamp: Date.now()
+      };
+      this.channel.emit(
+        `mesh.msg.${recipient.packId}`,
+        meshMessageToJson(msg),
+        MESH_EMIT
+      );
+      messages.push(msg);
+    }
+    return messages;
+  }
+  async request(from, to, payload, options = {}) {
+    this.assertOpen();
+    this.assertRegistered(from);
+    this.assertRegistered(to);
+    const timeoutMs = options.timeoutMs ?? 3e4;
+    const msg = {
+      id: generateMeshMsgId(from, to, ++this.msgCounter),
+      from,
+      to,
+      payload,
+      timestamp: Date.now()
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(
+          new Error(
+            `PackMesh: request from "${from}" to "${to}" timed out after ${timeoutMs}ms`
+          )
+        );
+      }, timeoutMs);
+      const cleanup = this.onMessage(from, (reply) => {
+        if (reply.replyTo === msg.id) {
+          clearTimeout(timer);
+          cleanup();
+          resolve(reply);
+        }
+      });
+      this.channel.emit(
+        `mesh.msg.${to}`,
+        meshMessageToJson(msg),
+        MESH_EMIT
+      );
+    });
+  }
+  reply(original, payload) {
+    this.assertOpen();
+    const replyMsg = {
+      id: generateMeshMsgId(original.to, original.from, ++this.msgCounter),
+      from: original.to,
+      to: original.from,
+      payload,
+      replyTo: original.id,
+      timestamp: Date.now()
+    };
+    this.channel.emit(
+      `mesh.msg.${original.from}`,
+      meshMessageToJson(replyMsg),
+      MESH_EMIT
+    );
+    return replyMsg;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    const ids = [...this.packs.keys()];
+    for (const id of ids) {
+      const entry = this.packs.get(id);
+      this.packs.delete(id);
+      this.emitPresence(id, "offline", entry.capabilities);
+    }
+    this.handlers.clear();
+    this.remotePacks.clear();
+    for (const unsub of this.subscriptions) {
+      unsub();
+    }
+    this.subscriptions.length = 0;
+  }
+  deliverToTarget(targetPackId, msg) {
+    const remote = this.remotePacks.get(targetPackId);
+    if (remote) {
+      void remote.run(JSON.stringify(msg)).catch((error) => {
+        this.emitDeliveryError(targetPackId, msg, error);
+      });
+      return;
+    }
+    const set = this.handlers.get(targetPackId);
+    if (!set) return;
+    for (const handler of set) {
+      try {
+        handler(msg);
+      } catch {
+      }
+    }
+  }
+  emitDeliveryError(targetPackId, msg, error) {
+    const event = {
+      targetPackId,
+      messageId: msg.id,
+      from: msg.from,
+      to: msg.to,
+      error: summarizeError(error),
+      timestamp: Date.now()
+    };
+    try {
+      this.channel.emit(
+        "mesh.delivery.error",
+        deliveryErrorToJson(event),
+        MESH_EMIT
+      );
+    } catch {
+    }
+  }
+  emitPresence(packId, status, capabilities) {
+    const event = {
+      packId,
+      status,
+      capabilities,
+      timestamp: Date.now()
+    };
+    this.channel.emit(
+      `mesh.presence.${status}`,
+      presenceToJson(event),
+      MESH_EMIT
+    );
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new Error("PackMesh: mesh is closed");
+    }
+  }
+  assertRegistered(packId) {
+    if (!this.packs.has(packId)) {
+      throw new Error(`PackMesh: pack "${packId}" is not registered`);
+    }
+  }
+}
+export {
+  PackMesh
+};
+//# sourceMappingURL=pack-mesh.js.map