@pellux/goodvibes-sdk 0.25.8 → 0.25.11

package/dist/_internal/platform/companion/companion-chat-manager.js

@@ -23,17 +23,22 @@ import { randomUUID } from 'node:crypto';
 import { ConversationManager } from '../core/conversation.js';
 import { CompanionChatPersistence, defaultSessionsDir, } from './companion-chat-persistence.js';
 import { CompanionChatRateLimiter } from './companion-chat-rate-limiter.js';
+import { executeToolCalls as executeOrchestratorToolCalls } from '../core/orchestrator-tool-runtime.js';
 // ---------------------------------------------------------------------------
 // Idle GC constants (customisable for tests)
 // ---------------------------------------------------------------------------
 const DEFAULT_IDLE_ACTIVE_MS = 30 * 60 * 1_000; // 30 minutes with messages
 const DEFAULT_IDLE_EMPTY_MS = 5 * 60 * 1_000; // 5 minutes empty session
 const GC_INTERVAL_MS = 60 * 1_000; // sweep every minute
+const MAX_TOOL_ROUNDS_PER_TURN = 8;
 export class CompanionChatManager {
     sessions = new Map();
     provider;
     eventPublisher;
     toolRegistry;
+    permissionManager;
+    hookDispatcher;
+    runtimeBus;
     persistence;
     rateLimiter;
     idleActiveMs;
@@ -52,6 +57,9 @@ export class CompanionChatManager {
         this.provider = config.provider;
         this.eventPublisher = config.eventPublisher;
         this.toolRegistry = config.toolRegistry ?? null;
+        this.permissionManager = config.permissionManager ?? null;
+        this.hookDispatcher = config.hookDispatcher ?? null;
+        this.runtimeBus = config.runtimeBus ?? null;
         this.idleActiveMs = config.idleActiveMs ?? DEFAULT_IDLE_ACTIVE_MS;
         this.idleEmptyMs = config.idleEmptyMs ?? DEFAULT_IDLE_EMPTY_MS;
         // Persistence
@@ -309,91 +317,82 @@ export class CompanionChatManager {
         let assistantContent = '';
         const assistantMessageId = randomUUID();
         try {
-            const messages = session.conversation.getMessagesForLLM();
-            // Convert ProviderMessage[] to our minimal interface
-            const chatMessages = messages.map((m) => ({
-                role: m.role === 'user' ? 'user' : 'assistant',
-                content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-            }));
-            const stream = this.provider.chatStream(chatMessages, {
-                systemPrompt: session.meta.systemPrompt,
-                model: session.meta.model,
-                provider: session.meta.provider,
-                abortSignal,
-            });
-            for await (const chunk of stream) {
-                if (abortSignal.aborted)
-                    break;
-                switch (chunk.type) {
-                    case 'text_delta': {
-                        const delta = chunk.delta ?? '';
-                        assistantContent += delta;
-                        publish({ type: 'turn.delta', sessionId, turnId, delta });
+            const toolDefinitions = this.toolRegistry?.getToolDefinitions() ?? [];
+            let completed = false;
+            for (let round = 0; round < MAX_TOOL_ROUNDS_PER_TURN; round++) {
+                const stream = this.provider.chatStream([...session.conversation.getMessagesForLLM()], {
+                    systemPrompt: session.meta.systemPrompt,
+                    model: session.meta.model,
+                    provider: session.meta.provider,
+                    tools: toolDefinitions,
+                    abortSignal,
+                });
+                let roundAssistantContent = '';
+                const toolCalls = [];
+                for await (const chunk of stream) {
+                    if (abortSignal.aborted)
                         break;
-                    }
-                    case 'tool_call': {
-                        publish({
-                            type: 'turn.tool_call',
-                            sessionId,
-                            turnId,
-                            toolCallId: chunk.toolCallId ?? '',
-                            toolName: chunk.toolName ?? '',
-                            toolInput: chunk.toolInput ?? null,
-                        });
-                        // Execute via ToolRegistry if available
-                        if (this.toolRegistry && chunk.toolName && chunk.toolCallId) {
-                            const toolCallId = chunk.toolCallId;
-                            const toolName = chunk.toolName;
+                    switch (chunk.type) {
+                        case 'text_delta': {
+                            const delta = chunk.delta ?? '';
+                            roundAssistantContent += delta;
+                            assistantContent += delta;
+                            publish({ type: 'turn.delta', sessionId, turnId, delta });
+                            break;
+                        }
+                        case 'tool_call': {
+                            const toolCallId = chunk.toolCallId ?? '';
+                            const toolName = chunk.toolName ?? '';
                             const toolInput = (chunk.toolInput ?? {});
-                            try {
-                                const toolResult = await this.toolRegistry.execute(toolCallId, toolName, toolInput);
-                                publish({
-                                    type: 'turn.tool_result',
-                                    sessionId,
-                                    turnId,
-                                    toolCallId,
-                                    toolName,
-                                    result: toolResult.output ?? null,
-                                    isError: !toolResult.success,
-                                });
-                            }
-                            catch (toolErr) {
-                                const errMsg = toolErr instanceof Error ? toolErr.message : String(toolErr);
-                                publish({
-                                    type: 'turn.tool_result',
-                                    sessionId,
-                                    turnId,
-                                    toolCallId,
-                                    toolName,
-                                    result: errMsg,
-                                    isError: true,
-                                });
+                            publish({
+                                type: 'turn.tool_call',
+                                sessionId,
+                                turnId,
+                                toolCallId,
+                                toolName,
+                                toolInput,
+                            });
+                            if (toolCallId && toolName) {
+                                toolCalls.push({ id: toolCallId, name: toolName, arguments: toolInput });
                             }
+                            break;
                         }
-                        break;
-                    }
-                    case 'tool_result': {
-                        publish({
-                            type: 'turn.tool_result',
-                            sessionId,
-                            turnId,
-                            toolCallId: chunk.toolCallId ?? '',
-                            toolName: chunk.toolName ?? '',
-                            result: chunk.result ?? null,
-                            isError: chunk.isError ?? false,
-                        });
-                        break;
-                    }
-                    case 'error': {
-                        throw new Error(chunk.error ?? 'Provider streaming error');
+                        case 'tool_result': {
+                            publish({
+                                type: 'turn.tool_result',
+                                sessionId,
+                                turnId,
+                                toolCallId: chunk.toolCallId ?? '',
+                                toolName: chunk.toolName ?? '',
+                                result: chunk.result ?? null,
+                                isError: chunk.isError ?? false,
+                            });
+                            break;
+                        }
+                        case 'error': {
+                            throw new Error(chunk.error ?? 'Provider streaming error');
+                        }
+                        case 'done':
+                            break;
                     }
-                    case 'done':
-                        break;
                 }
+                if (abortSignal.aborted)
+                    break;
+                if (toolCalls.length === 0) {
+                    session.conversation.addAssistantMessage(roundAssistantContent);
+                    completed = true;
+                    break;
+                }
+                session.conversation.addAssistantMessage(roundAssistantContent, { toolCalls });
+                if (!this.toolRegistry) {
+                    completed = true;
+                    break;
+                }
+                const toolResults = await this._executeToolCalls(toolCalls, publish, sessionId, turnId);
+                session.conversation.addToolResults(toolResults);
             }
-            // Append assistant reply to conversation
-            if (assistantContent) {
-                session.conversation.addAssistantMessage(assistantContent);
+            if (!completed && !abortSignal.aborted) {
+                throw new Error(`Companion chat exceeded ${MAX_TOOL_ROUNDS_PER_TURN} tool rounds without a final response`);
             }
             const now = Date.now();
             const assistantMsg = {
@@ -429,6 +428,57 @@ export class CompanionChatManager {
             }
         }
     }
+    async _executeToolCalls(toolCalls, publish, sessionId, turnId) {
+        const toolRegistry = this.toolRegistry;
+        if (!toolRegistry)
+            return [];
+        if (!this.permissionManager) {
+            return toolCalls.map((call) => {
+                const toolResult = {
+                    callId: call.id,
+                    success: false,
+                    error: 'Tool execution denied: permission manager unavailable for companion chat',
+                };
+                publish({
+                    type: 'turn.tool_result',
+                    sessionId,
+                    turnId,
+                    toolCallId: call.id,
+                    toolName: call.name,
+                    result: toolResult.error,
+                    isError: true,
+                });
+                return toolResult;
+            });
+        }
+        const results = await executeOrchestratorToolCalls({
+            toolRegistry,
+            permissionManager: this.permissionManager,
+            hookDispatcher: this.hookDispatcher,
+            runtimeBus: this.runtimeBus,
+            sessionId,
+            emitterContext: (id) => ({
+                sessionId,
+                traceId: `${sessionId}:${id}`,
+                source: 'companion-chat',
+            }),
+        }, turnId, toolCalls);
+        for (const [index, toolResult] of results.entries()) {
+            const call = toolCalls[index];
+            if (!call)
+                continue;
+            publish({
+                type: 'turn.tool_result',
+                sessionId,
+                turnId,
+                toolCallId: call.id,
+                toolName: call.name,
+                result: toolResult.output ?? toolResult.error ?? null,
+                isError: !toolResult.success,
+            });
+        }
+        return results;
+    }
     // ---------------------------------------------------------------------------
     // GC sweep
     // ---------------------------------------------------------------------------

package/dist/_internal/platform/config/schema-domain-runtime.d.ts

@@ -21,10 +21,34 @@ export declare const runtimeConfigDefaults: {
     cloudflare: {
         enabled: boolean;
         freeTierMode: boolean;
+        accountId: string;
+        apiTokenRef: string;
+        zoneId: string;
+        zoneName: string;
+        workerName: string;
+        workerSubdomain: string;
+        workerHostname: string;
         workerBaseUrl: string;
+        daemonBaseUrl: string;
+        daemonHostname: string;
         workerTokenRef: string;
+        workerClientTokenRef: string;
+        workerCron: string;
         queueName: string;
         deadLetterQueueName: string;
+        tunnelName: string;
+        tunnelId: string;
+        tunnelTokenRef: string;
+        accessAppId: string;
+        accessServiceTokenId: string;
+        accessServiceTokenRef: string;
+        kvNamespaceName: string;
+        kvNamespaceId: string;
+        durableObjectNamespaceName: string;
+        durableObjectNamespaceId: string;
+        r2BucketName: string;
+        secretsStoreName: string;
+        secretsStoreId: string;
         maxQueueOpsPerDay: number;
     };
     telemetry: {

package/dist/_internal/platform/config/schema-domain-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-domain-runtime.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/config/schema-domain-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGjC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,uBAAuB,EAyMjE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,uBAAuB,EA8NnE,CAAC"}
+{"version":3,"file":"schema-domain-runtime.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/config/schema-domain-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2HjC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,uBAAuB,EAyMjE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,uBAAuB,EA+WnE,CAAC"}

package/dist/_internal/platform/config/schema-domain-runtime.js

@@ -20,10 +20,34 @@ export const runtimeConfigDefaults = {
     cloudflare: {
         enabled: false,
         freeTierMode: true,
+        accountId: '',
+        apiTokenRef: '',
+        zoneId: '',
+        zoneName: '',
+        workerName: 'goodvibes-batch-worker',
+        workerSubdomain: '',
+        workerHostname: '',
         workerBaseUrl: '',
+        daemonBaseUrl: '',
+        daemonHostname: '',
         workerTokenRef: '',
+        workerClientTokenRef: '',
+        workerCron: '*/5 * * * *',
         queueName: 'goodvibes-batch',
         deadLetterQueueName: 'goodvibes-batch-dlq',
+        tunnelName: 'goodvibes-daemon',
+        tunnelId: '',
+        tunnelTokenRef: '',
+        accessAppId: '',
+        accessServiceTokenId: '',
+        accessServiceTokenRef: '',
+        kvNamespaceName: 'goodvibes-runtime',
+        kvNamespaceId: '',
+        durableObjectNamespaceName: 'GoodVibesCoordinator',
+        durableObjectNamespaceId: '',
+        r2BucketName: 'goodvibes-artifacts',
+        secretsStoreName: 'goodvibes',
+        secretsStoreId: '',
         maxQueueOpsPerDay: 10_000,
     },
     telemetry: {
@@ -488,18 +512,85 @@ export const runtimeSecondaryConfigSettings = [
         default: true,
         description: 'Prefer Cloudflare usage patterns that fit the free tier: small queue signals, local daemon storage, and bounded daily queue volume',
     },
+    {
+        key: 'cloudflare.accountId',
+        type: 'string',
+        default: '',
+        description: 'Cloudflare account id used by SDK-owned Worker/Queue provisioning',
+    },
+    {
+        key: 'cloudflare.apiTokenRef',
+        type: 'string',
+        default: '',
+        description: 'GoodVibes secret reference for the Cloudflare API token. If empty, the SDK falls back to CLOUDFLARE_API_TOKEN.',
+    },
+    {
+        key: 'cloudflare.zoneId',
+        type: 'string',
+        default: '',
+        description: 'Optional Cloudflare zone id selected for SDK-managed DNS and Zero Trust Access hostnames',
+    },
+    {
+        key: 'cloudflare.zoneName',
+        type: 'string',
+        default: '',
+        description: 'Optional Cloudflare zone name selected during discovery/onboarding when zone id is not known yet',
+    },
+    {
+        key: 'cloudflare.workerName',
+        type: 'string',
+        default: 'goodvibes-batch-worker',
+        description: 'Cloudflare Worker script name managed by GoodVibes provisioning',
+        validate: (v) => typeof v === 'string' && (/^[a-z0-9][a-z0-9-]{0,62}$/i.test(v) || v === ''),
+    },
+    {
+        key: 'cloudflare.workerSubdomain',
+        type: 'string',
+        default: '',
+        description: 'Cloudflare account workers.dev subdomain used to infer cloudflare.workerBaseUrl',
+    },
+    {
+        key: 'cloudflare.workerHostname',
+        type: 'string',
+        default: '',
+        description: 'Optional custom hostname for the GoodVibes Cloudflare Worker when DNS automation is enabled',
+    },
     {
         key: 'cloudflare.workerBaseUrl',
         type: 'string',
         default: '',
         description: 'Optional deployed GoodVibes Cloudflare Worker base URL used by clients that proxy batch signals through Workers',
     },
+    {
+        key: 'cloudflare.daemonBaseUrl',
+        type: 'string',
+        default: '',
+        description: 'Daemon origin URL the Cloudflare Worker or Tunnel uses for Worker-to-daemon batch calls',
+    },
+    {
+        key: 'cloudflare.daemonHostname',
+        type: 'string',
+        default: '',
+        description: 'Optional public daemon hostname managed through Cloudflare DNS, Tunnel, and Access provisioning',
+    },
     {
         key: 'cloudflare.workerTokenRef',
         type: 'string',
         default: '',
         description: 'Optional GoodVibes secret reference for the Worker-to-daemon bearer token',
     },
+    {
+        key: 'cloudflare.workerClientTokenRef',
+        type: 'string',
+        default: '',
+        description: 'Optional GoodVibes secret reference for the bearer token clients use when calling the Cloudflare Worker',
+    },
+    {
+        key: 'cloudflare.workerCron',
+        type: 'string',
+        default: '*/5 * * * *',
+        description: 'Cron trigger installed on the GoodVibes Cloudflare Worker for batch scheduler ticks',
+    },
     {
         key: 'cloudflare.queueName',
         type: 'string',
@@ -512,6 +603,84 @@ export const runtimeSecondaryConfigSettings = [
         default: 'goodvibes-batch-dlq',
         description: 'Cloudflare dead-letter queue binding/name for failed GoodVibes batch job signals',
     },
+    {
+        key: 'cloudflare.tunnelName',
+        type: 'string',
+        default: 'goodvibes-daemon',
+        description: 'Zero Trust Tunnel name managed by GoodVibes provisioning when tunnel integration is enabled',
+    },
+    {
+        key: 'cloudflare.tunnelId',
+        type: 'string',
+        default: '',
+        description: 'Cloudflare Zero Trust Tunnel id selected or created by GoodVibes provisioning',
+    },
+    {
+        key: 'cloudflare.tunnelTokenRef',
+        type: 'string',
+        default: '',
+        description: 'GoodVibes secret reference for the cloudflared tunnel token generated by provisioning',
+    },
+    {
+        key: 'cloudflare.accessAppId',
+        type: 'string',
+        default: '',
+        description: 'Cloudflare Zero Trust Access application id protecting the GoodVibes daemon hostname',
+    },
+    {
+        key: 'cloudflare.accessServiceTokenId',
+        type: 'string',
+        default: '',
+        description: 'Cloudflare Zero Trust Access service token id created for GoodVibes daemon access',
+    },
+    {
+        key: 'cloudflare.accessServiceTokenRef',
+        type: 'string',
+        default: '',
+        description: 'GoodVibes secret reference storing Access service token client id/secret JSON',
+    },
+    {
+        key: 'cloudflare.kvNamespaceName',
+        type: 'string',
+        default: 'goodvibes-runtime',
+        description: 'Cloudflare KV namespace name used for optional edge runtime state',
+    },
+    {
+        key: 'cloudflare.kvNamespaceId',
+        type: 'string',
+        default: '',
+        description: 'Cloudflare KV namespace id used for the GoodVibes Worker binding',
+    },
+    {
+        key: 'cloudflare.durableObjectNamespaceName',
+        type: 'string',
+        default: 'GoodVibesCoordinator',
+        description: 'Cloudflare Durable Object class/namespace name used for optional edge coordination',
+    },
+    {
+        key: 'cloudflare.durableObjectNamespaceId',
+        type: 'string',
+        default: '',
+        description: 'Cloudflare Durable Object namespace id discovered after Worker migration',
+    },
+    {
+        key: 'cloudflare.r2BucketName',
+        type: 'string',
+        default: 'goodvibes-artifacts',
+        description: 'Cloudflare R2 Standard bucket name used for optional GoodVibes artifacts',
+    },
+    {
+        key: 'cloudflare.secretsStoreName',
+        type: 'string',
+        default: 'goodvibes',
+        description: 'Cloudflare Secrets Store name managed by optional GoodVibes provisioning',
+    },
+    {
+        key: 'cloudflare.secretsStoreId',
+        type: 'string',
+        default: '',
+        description: 'Cloudflare Secrets Store id selected or created by GoodVibes provisioning',
+    },
     {
         key: 'cloudflare.maxQueueOpsPerDay',
         type: 'number',

package/dist/_internal/platform/config/schema-domain-surfaces.d.ts

@@ -36,6 +36,17 @@ export declare const surfaceConfigDefaults: {
         secret: string;
         setupVersion: number;
     };
+    homeassistant: {
+        enabled: boolean;
+        instanceUrl: string;
+        accessToken: string;
+        webhookSecret: string;
+        defaultConversationId: string;
+        deviceId: string;
+        deviceName: string;
+        eventType: string;
+        setupVersion: number;
+    };
     telegram: {
         enabled: boolean;
         botToken: string;

package/dist/_internal/platform/config/schema-domain-surfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-domain-surfaces.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/config/schema-domain-surfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoHjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,uBAAuB,EAmU1D,CAAC"}
+{"version":3,"file":"schema-domain-surfaces.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/config/schema-domain-surfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,uBAAuB,EAmX1D,CAAC"}

package/dist/_internal/platform/config/schema-domain-surfaces.js

@@ -35,6 +35,17 @@ export const surfaceConfigDefaults = {
         secret: '',
         setupVersion: 0,
     },
+    homeassistant: {
+        enabled: false,
+        instanceUrl: '',
+        accessToken: '',
+        webhookSecret: '',
+        defaultConversationId: 'goodvibes',
+        deviceId: 'goodvibes-daemon',
+        deviceName: 'GoodVibes Daemon',
+        eventType: 'goodvibes_message',
+        setupVersion: 0,
+    },
     telegram: {
         enabled: false,
         botToken: '',
@@ -262,6 +273,54 @@ export const surfaceConfigSettings = [
         default: '',
         description: 'Shared secret used to sign or verify webhook payloads',
     },
+    {
+        key: 'surfaces.homeassistant.enabled',
+        type: 'boolean',
+        default: false,
+        description: 'Enable the Home Assistant daemon surface',
+    },
+    {
+        key: 'surfaces.homeassistant.instanceUrl',
+        type: 'string',
+        default: '',
+        description: 'Home Assistant base URL, for example http://homeassistant.local:8123',
+    },
+    {
+        key: 'surfaces.homeassistant.accessToken',
+        type: 'string',
+        default: '',
+        description: 'Home Assistant long-lived access token or goodvibes secret URI',
+    },
+    {
+        key: 'surfaces.homeassistant.webhookSecret',
+        type: 'string',
+        default: '',
+        description: 'Shared secret used to verify inbound Home Assistant callbacks',
+    },
+    {
+        key: 'surfaces.homeassistant.defaultConversationId',
+        type: 'string',
+        default: 'goodvibes',
+        description: 'Default Home Assistant conversation id used for route binding',
+    },
+    {
+        key: 'surfaces.homeassistant.deviceId',
+        type: 'string',
+        default: 'goodvibes-daemon',
+        description: 'Stable Home Assistant device identifier for this daemon',
+    },
+    {
+        key: 'surfaces.homeassistant.deviceName',
+        type: 'string',
+        default: 'GoodVibes Daemon',
+        description: 'Home Assistant device display name for this daemon',
+    },
+    {
+        key: 'surfaces.homeassistant.eventType',
+        type: 'string',
+        default: 'goodvibes_message',
+        description: 'Home Assistant event type used for daemon-to-Home Assistant deliveries',
+    },
     {
         key: 'surfaces.telegram.enabled',
         type: 'boolean',