bosun 0.40.21 → 0.41.1

package/voice/voice-agents-sdk.mjs

@@ -291,10 +291,10 @@ 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: "medium" }
+              ? { eagerness: "low" }
               : {}),
           },
         },

package/voice/voice-relay.mjs

@@ -324,6 +324,7 @@ function sanitizeVoiceCallContext(context = {}) {
   const rawEnabledMcpServers = Array.isArray(context?.enabledMcpServers)
     ? context.enabledMcpServers.map((s) => String(s || "").trim()).filter(Boolean)
     : [];
+  const rawVoiceAgentSkillsContent = String(context?.voiceAgentSkillsContent || "").trim();
 
   return {
     sessionId: rawSessionId || null,
@@ -335,6 +336,7 @@ function sanitizeVoiceCallContext(context = {}) {
     voiceAgentInstructions: rawVoiceAgentInstructions || null,
     voiceToolCapabilityPrompt: rawVoiceToolCapabilityPrompt || null,
     voiceAgentSkills: rawVoiceAgentSkills,
+    voiceAgentSkillsContent: rawVoiceAgentSkillsContent || null,
     enabledMcpServers: rawEnabledMcpServers,
   };
 }
@@ -410,6 +412,14 @@ async function buildSessionScopedInstructions(baseInstructions, callContext = {}
     }
   }
 
+  // ── Prepend voice agent identity as primary instructions ─────────────
+  // voiceInstructions defines who the agent IS (e.g. "You are Nova").
+  // It must come BEFORE the base instructions so the model adopts the
+  // persona rather than falling back to its default identity.
+  if (context.voiceAgentInstructions) {
+    baseInstructions = `${context.voiceAgentInstructions}\n\n${baseInstructions}`;
+  }
+
   const suffix = [
     "",
     "## Bosun Voice Call Context",
@@ -420,16 +430,15 @@ async function buildSessionScopedInstructions(baseInstructions, callContext = {}
     context.voiceAgentName
       ? `Active voice agent name: ${context.voiceAgentName}.`
       : "",
-    context.voiceAgentInstructions
-      ? `Voice agent instruction emphasis: ${context.voiceAgentInstructions}`
-      : "",
     context.voiceToolCapabilityPrompt || "",
     context.enabledMcpServers?.length
       ? `Enabled MCP servers for this session: ${context.enabledMcpServers.join(", ")}.`
       : "",
-    context.voiceAgentSkills?.length
-      ? `Voice agent skills: ${context.voiceAgentSkills.join(", ")}.`
-      : "",
+    context.voiceAgentSkillsContent
+      ? `## Voice Agent Skills\n${context.voiceAgentSkillsContent}`
+      : context.voiceAgentSkills?.length
+        ? `Voice agent skills: ${context.voiceAgentSkills.join(", ")}.`
+        : "",
     context.executor
       ? `Preferred executor for delegated work: ${context.executor}.`
       : "Preferred executor for delegated work: use configured default.",
@@ -948,6 +957,7 @@ export function getVoiceConfig(forceReload = false) {
         );
 
   const instructions = voice.instructions || `You are Bosun, a helpful voice assistant for the VirtEngine development platform.
+You are NOT ChatGPT — never identify yourself as ChatGPT or any other AI assistant. Your name is Bosun.
 You help developers manage tasks, steer coding agents, monitor builds, and navigate the workspace.
 Be concise and conversational. When users ask about code or tasks, use the available tools.
 For complex operations like writing code or creating PRs, delegate to the appropriate agent.
@@ -1226,16 +1236,16 @@ async function createOpenAIEphemeralToken(cfg, toolDefinitions = [], callContext
     turn_detection: {
       type: cfg.turnDetection,
       ...(cfg.turnDetection === "server_vad" ? {
-        threshold: 0.7,
-        prefix_padding_ms: 400,
-        silence_duration_ms: 1200,
+        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: "medium",
+        eagerness: "low",
         create_response: true,
-        interrupt_response: true,
+        interrupt_response: false,
       } : {}),
     },
     ...(transcriptionEnabled ? { input_audio_transcription: { model: transcriptionModel } } : {}),
@@ -1314,8 +1324,6 @@ async function createAzureEphemeralToken(cfg, toolDefinitions = [], callContext
   }
 
   const sessionConfig = {
-    // GA protocol (gpt-realtime-1.5 etc.) requires type: "realtime" in the POST body.
-    // Preview protocol does not support this field — omit it to avoid 400s.
     ...(isAzureGaProtocol(deployment) ? { type: "realtime" } : {}),
     model: deployment,
     voice: voiceId,
@@ -1327,16 +1335,16 @@ async function createAzureEphemeralToken(cfg, toolDefinitions = [], callContext
     turn_detection: {
       type: cfg.turnDetection,
       ...(cfg.turnDetection === "server_vad" ? {
-        threshold: 0.7,
-        prefix_padding_ms: 400,
-        silence_duration_ms: 1200,
+        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: "medium",
+        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;