bosun 0.41.0 → 0.41.2

package/voice/voice-agents-sdk.mjs

@@ -291,7 +291,7 @@ export async function createRealtimeSession(agent, provider, config = {}, option
           turnDetection: {
             type: turnDetection,
             ...(turnDetection === "server_vad"
-              ? { threshold: 0.5, prefix_padding_ms: 300, silence_duration_ms: 500 }
+              ? { threshold: 0.75, prefix_padding_ms: 500, silence_duration_ms: 1200 }
               : {}),
             ...(turnDetection === "semantic_vad"
               ? { eagerness: "low" }

package/voice/voice-relay.mjs

@@ -1236,16 +1236,16 @@ async function createOpenAIEphemeralToken(cfg, toolDefinitions = [], callContext
     turn_detection: {
       type: cfg.turnDetection,
       ...(cfg.turnDetection === "server_vad" ? {
-        threshold: 0.55,
+        threshold: 0.75,
         prefix_padding_ms: 500,
         silence_duration_ms: 1800,
         create_response: true,
-        interrupt_response: true,
+        interrupt_response: false,
       } : {}),
       ...(cfg.turnDetection === "semantic_vad" ? {
         eagerness: "low",
         create_response: true,
-        interrupt_response: true,
+        interrupt_response: false,
       } : {}),
     },
     ...(transcriptionEnabled ? { input_audio_transcription: { model: transcriptionModel } } : {}),
@@ -1335,16 +1335,16 @@ async function createAzureEphemeralToken(cfg, toolDefinitions = [], callContext
     turn_detection: {
       type: cfg.turnDetection,
       ...(cfg.turnDetection === "server_vad" ? {
-        threshold: 0.55,
+        threshold: 0.75,
         prefix_padding_ms: 500,
         silence_duration_ms: 1800,
         create_response: true,
-        interrupt_response: true,
+        interrupt_response: false,
       } : {}),
       ...(cfg.turnDetection === "semantic_vad" ? {
         eagerness: "low",
         create_response: true,
-        interrupt_response: true,
+        interrupt_response: false,
       } : {}),
     },
     ...(transcriptionEnabled ? { input_audio_transcription: { model: transcriptionModel } } : {}),

package/workflow/declarative-workflows.mjs

@@ -0,0 +1,145 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { execWithRetry, getPoolSdkName } from "../agent/agent-pool.mjs";
+import { loadConfig } from "../config/config.mjs";
+import {
+  BUILTIN_WORKFLOWS,
+  createConfiguredPipeline,
+  listWorkflowDefinitions,
+  resolveWorkflowDefinition,
+  runConfiguredWorkflow as runPipelineConfiguredWorkflow,
+} from "./pipeline.mjs";
+
+function normalizeWorkflowDefinition(name, definition = {}, config = {}) {
+  const resolved = resolveWorkflowDefinition(name, {
+    ...(config.workflows || {}),
+    [name]: definition,
+  });
+  return resolved?.definition || null;
+}
+
+function listConfiguredWorkflows(config = {}) {
+  return listWorkflowDefinitions(config.workflows || {}).map((entry) => {
+    const definition = entry?.definition || {};
+    const rawAgents = Array.isArray(definition.stages) && definition.stages.length > 0
+      ? definition.stages
+      : Array.isArray(definition.agents)
+        ? definition.agents
+        : [];
+    return {
+      id: definition.id || entry?.name,
+      name: definition.name || entry?.name,
+      type: definition.type || "sequential",
+      description: definition.description || "",
+      source: entry?.source || "unknown",
+      agents: rawAgents.map((agent, index) => {
+        if (typeof agent === "string") {
+          return { id: agent, name: agent, role: agent, sdk: null };
+        }
+        return {
+          id: agent?.id || agent?.name || `agent-${index + 1}`,
+          name: agent?.name || agent?.id || `agent-${index + 1}`,
+          role: agent?.stage || agent?.role || null,
+          sdk: agent?.sdk || agent?.executor || null,
+        };
+      }),
+    };
+  });
+}
+
+function buildConsensus(result) {
+  const votes = new Map();
+  for (const output of result.outputs || []) {
+    const text = String(output.summary || output.output || "").trim();
+    if (!text) continue;
+    votes.set(text, (votes.get(text) || 0) + 1);
+  }
+  let winner = null;
+  for (const [text, count] of votes.entries()) {
+    if (!winner || count > winner.count) winner = { text, count };
+  }
+  return winner;
+}
+
+function createWorkflowAgentPool(options = {}) {
+  if (options.dryRun === true) {
+    return {
+      getPoolSdkName,
+      async execWithRetry(prompt, execOptions = {}) {
+        const sdk = execOptions.sdk || getPoolSdkName() || "codex";
+        return {
+          success: true,
+          output: `[${sdk}] ${String(prompt).split("\n")[0]}`,
+          sdk,
+          attempts: 1,
+          usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        };
+      },
+    };
+  }
+  return { execWithRetry, getPoolSdkName };
+}
+
+async function runConfiguredWorkflow(name, input, options = {}) {
+  const config = options.config || loadConfig();
+  const result = await runPipelineConfiguredWorkflow(name, input, {
+    workflows: config.workflows || {},
+    services: {
+      agentPool: options.services?.agentPool || createWorkflowAgentPool(options),
+    },
+    runOptions: options.runOptions || {},
+  });
+
+  const resolved = resolveWorkflowDefinition(name, config.workflows || {});
+  const workflow = resolved?.definition || { id: name, name, type: "sequential" };
+  const status = result.success ? "success" : "failed";
+  return {
+    ...result,
+    status,
+    workflow: {
+      id: workflow.id || name,
+      name: workflow.name || name,
+      type: workflow.type || "sequential",
+    },
+    consensus:
+      String(workflow.id || name) === "consensus-vote" ? buildConsensus(result) : undefined,
+  };
+}
+
+function loadWorkflowInputFromFile(pathValue) {
+  const fullPath = resolve(pathValue);
+  const raw = readFileSync(fullPath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+function createWorkflowInstance(definition, options = {}) {
+  return createConfiguredPipeline(definition, {
+    services: {
+      agentPool: options.services?.agentPool || createWorkflowAgentPool(options),
+    },
+    hub: options.hub,
+    createHub: options.createHub,
+    hubOptions: options.hubOptions,
+  });
+}
+
+export {
+  BUILTIN_WORKFLOWS,
+  normalizeWorkflowDefinition,
+  listConfiguredWorkflows,
+  loadWorkflowInputFromFile,
+  createWorkflowInstance,
+  runConfiguredWorkflow,
+};
+export default {
+  BUILTIN_WORKFLOWS,
+  normalizeWorkflowDefinition,
+  listConfiguredWorkflows,
+  loadWorkflowInputFromFile,
+  createWorkflowInstance,
+  runConfiguredWorkflow,
+};

package/workflow/msg-hub.mjs

@@ -0,0 +1,237 @@
+/**
+ * @module msg-hub
+ * @description Lightweight reference-passing message hub for active agents.
+ */
+
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+
+const DEFAULT_HISTORY_LIMIT = 100;
+const DEFAULT_MAX_MESSAGE_BYTES = 4096;
+const DISALLOWED_KEYS = new Set([
+  "context",
+  "conversation",
+  "history",
+  "messages",
+  "raw",
+  "transcript",
+]);
+const ALLOWED_KEYS = [
+  "kind",
+  "taskId",
+  "taskIds",
+  "workflowId",
+  "runId",
+  "branch",
+  "filePaths",
+  "paths",
+  "summary",
+  "metadata",
+  "source",
+];
+
+function truncateText(value, limit = 320) {
+  const text = String(value ?? "").trim();
+  if (!text) return "";
+  if (text.length <= limit) return text;
+  return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+
+function normalizeParticipant(participant) {
+  if (typeof participant === "string") {
+    return {
+      id: participant,
+      name: participant,
+      onMessage: null,
+    };
+  }
+  if (!participant || typeof participant !== "object") {
+    throw new TypeError("MsgHub participant must be a string or object.");
+  }
+  const id = String(participant.id || participant.name || randomUUID()).trim();
+  if (!id) throw new Error("MsgHub participant must have an id or name.");
+  return {
+    id,
+    name: String(participant.name || id),
+    onMessage:
+      typeof participant.onMessage === "function"
+        ? participant.onMessage.bind(participant)
+        : null,
+  };
+}
+
+function sanitizeReference(message, maxBytes) {
+  const raw =
+    message && typeof message === "object" && !Array.isArray(message)
+      ? message
+      : { summary: String(message ?? "") };
+  const ref = {};
+
+  for (const key of ALLOWED_KEYS) {
+    if (raw[key] == null) continue;
+    if (key === "summary") {
+      ref.summary = truncateText(raw.summary);
+      continue;
+    }
+    if (key === "filePaths" || key === "paths") {
+      const values = Array.isArray(raw[key])
+        ? raw[key].map((entry) => String(entry || "").trim()).filter(Boolean)
+        : [];
+      if (values.length > 0) ref[key] = [...new Set(values)];
+      continue;
+    }
+    ref[key] = raw[key];
+  }
+
+  for (const [key, value] of Object.entries(raw)) {
+    if (key.startsWith("_")) continue;
+    if (DISALLOWED_KEYS.has(key) || ALLOWED_KEYS.includes(key)) continue;
+    if (value == null) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      if (!ref.metadata || typeof ref.metadata !== "object") ref.metadata = {};
+      ref.metadata[key] = typeof value === "string" ? truncateText(value, 120) : value;
+    }
+  }
+
+  let serialized = JSON.stringify(ref);
+  if (Buffer.byteLength(serialized, "utf8") <= maxBytes) {
+    return ref;
+  }
+
+  if (ref.metadata && typeof ref.metadata === "object") {
+    ref.metadata = { note: "trimmed" };
+  }
+  if (ref.summary) {
+    ref.summary = truncateText(ref.summary, 160);
+  }
+  serialized = JSON.stringify(ref);
+  if (Buffer.byteLength(serialized, "utf8") <= maxBytes) {
+    return ref;
+  }
+
+  return {
+    kind: ref.kind || "reference",
+    taskId: ref.taskId || null,
+    branch: ref.branch || null,
+    summary: truncateText(ref.summary || "reference trimmed", 96),
+  };
+}
+
+export class MsgHub extends EventEmitter {
+  static async create(participants = [], options = {}) {
+    return new MsgHub(participants, options);
+  }
+
+  constructor(participants = [], options = {}) {
+    super();
+    this.options = {
+      autoBroadcast: options.autoBroadcast !== false,
+      historyLimit: Number(options.historyLimit || DEFAULT_HISTORY_LIMIT),
+      maxMessageBytes: Number(options.maxMessageBytes || DEFAULT_MAX_MESSAGE_BYTES),
+    };
+    this._participants = new Map();
+    this._history = [];
+    this._closed = false;
+    for (const participant of participants) {
+      this.add(participant);
+    }
+  }
+
+  add(participant) {
+    if (this._closed) throw new Error("MsgHub is closed.");
+    const normalized = normalizeParticipant(participant);
+    this._participants.set(normalized.id, normalized);
+    this.emit("participant:added", {
+      participantId: normalized.id,
+      participantName: normalized.name,
+      size: this._participants.size,
+    });
+    return normalized;
+  }
+
+  remove(participantOrId) {
+    const id = typeof participantOrId === "string"
+      ? participantOrId
+      : participantOrId?.id || participantOrId?.name || "";
+    const removed = this._participants.delete(String(id || "").trim());
+    if (removed) {
+      this.emit("participant:removed", {
+        participantId: String(id || "").trim(),
+        size: this._participants.size,
+      });
+    }
+    return removed;
+  }
+
+  listParticipants() {
+    return [...this._participants.values()].map((participant) => ({
+      id: participant.id,
+      name: participant.name,
+    }));
+  }
+
+  get history() {
+    return this._history.map((entry) => ({ ...entry }));
+  }
+
+  subscribe(listener) {
+    this.on("message", listener);
+    return () => this.off("message", listener);
+  }
+
+  async publish(from, message, options = {}) {
+    if (this._closed) throw new Error("MsgHub is closed.");
+    const senderId = typeof from === "string"
+      ? String(from).trim()
+      : String(from?.id || from?.name || "").trim();
+    if (senderId && !this._participants.has(senderId)) {
+      this.add(senderId);
+    }
+
+    const to = Array.isArray(options.to)
+      ? options.to.map((entry) => String(entry || "").trim()).filter(Boolean)
+      : null;
+    const recipients = to || [...this._participants.keys()].filter((id) => id !== senderId);
+    const envelope = {
+      id: randomUUID(),
+      from: senderId || null,
+      to: recipients,
+      message: sanitizeReference(message, this.options.maxMessageBytes),
+      timestamp: new Date().toISOString(),
+      timestampMs: Date.now(),
+    };
+
+    this._history.push(envelope);
+    if (this._history.length > this.options.historyLimit) {
+      this._history.splice(0, this._history.length - this.options.historyLimit);
+    }
+
+    this.emit("message", envelope);
+    if (this.options.autoBroadcast) {
+      for (const recipientId of recipients) {
+        const participant = this._participants.get(recipientId);
+        if (!participant?.onMessage) continue;
+        try {
+          await participant.onMessage(envelope, this);
+        } catch (error) {
+          this.emit("delivery:error", {
+            participantId: recipientId,
+            error: String(error?.message || error),
+            envelope,
+          });
+        }
+      }
+    }
+    return envelope;
+  }
+
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._participants.clear();
+    this.emit("closed", { closedAt: new Date().toISOString() });
+    this.removeAllListeners();
+  }
+}
+
+export default MsgHub;