@noodleseed/one 0.170.0 → 0.171.0

package/node_modules/@noodle-borg/service/dist/channels/runtime.js

@@ -0,0 +1,337 @@
+import { beginChannelProviderBlock, CHANNEL_RETENTION_MS, ChannelCoordinator, ChannelError, channelDigest, channelProviderBlocks, finishChannelProviderBlock, messagingSurfaceOf, projectArtifactForSurface, resolveInvocationContextSnapshot, withAssistantTurnExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { runAgentTurn } from '../routes/assistant-agent.js';
+import { resolveAssistantKnowledge } from '../routes/assistant-knowledge.js';
+import { resolveAssistantModelBinding } from '../routes/assistant-model-binding.js';
+import { activeAssistantTarget } from '../routes/assistant-session-target.js';
+import { resolveConfigScope } from '../store.js';
+import { Dialog360, verifyWhatsAppWebhookSecret, WHATSAPP_CALLBACK_HEADER } from './360dialog.js';
+import { verifiedInferenceBound, withChannelInferenceGuard } from './inference-guard.js';
+export class WhatsAppRuntime {
+    options;
+    deps;
+    channels;
+    cursor;
+    constructor(options, deps) {
+        this.options = options;
+        this.deps = deps;
+        this.channels = new ChannelCoordinator(options.store, () => deps.clock?.().getTime() ?? Date.now());
+        options.worker.attach(() => this.sweep());
+    }
+    async provider(binding) {
+        const values = await this.deps.registry.configStore.resolveConfigValues('secret', resolveConfigScope(binding.tenant));
+        const apiKey = values[binding.apiKeySecret], webhookSecret = values[binding.webhookSecret];
+        if (!apiKey ||
+            !webhookSecret ||
+            apiKey === webhookSecret ||
+            !verifyWhatsAppWebhookSecret(webhookSecret, webhookSecret))
+            throw new ChannelError('channel_credentials_missing');
+        await this.channels.checkCredentials(binding.id, channelDigest(JSON.stringify([apiKey, webhookSecret])));
+        return { adapter: new Dialog360(apiKey, this.options.providerFetch), webhookSecret };
+    }
+    webhookUrl(req, binding) {
+        return `${this.deps.serviceBase(req).replace(/\/$/, '')}/v1/channels/whatsapp/webhooks/${binding.id}`;
+    }
+    async target(binding) {
+        const target = await activeAssistantTarget(this.deps, binding.tenant);
+        if (!target || target.deploymentId !== binding.deploymentId)
+            throw new ChannelError('deployment_changed');
+        const surface = messagingSurfaceOf(target.served.artifact.server.assistant);
+        if (!surface)
+            throw new ChannelError('messaging_surface_missing');
+        if (binding.capabilities.some((cap) => !surface.capabilities.some((authored) => authored.kind === cap.kind && authored.name === cap.name)))
+            throw new ChannelError('capability_not_authored');
+        const artifact = projectArtifactForSurface(target.served.artifact, binding.capabilities);
+        if (artifact.tools.some((tool) => tool.annotations?.readOnlyHint !== true || tool._meta?.ui))
+            throw new ChannelError('messaging_action_unsupported');
+        // This first slice has no separately budgeted connector-backed inference. Pure reads and
+        // the existing corpus search remain available; external lookups require their owning slice.
+        const external = (fulfilment) => fulfilment.kind === 'operation' || fulfilment.steps.some((step) => step.kind === 'operation');
+        if (artifact.tools.some((tool) => external(tool.fulfilment)) ||
+            (artifact.server.context?.ambient && external(artifact.server.context.ambient.fulfilment)))
+            throw new ChannelError('external_lookup_not_enabled');
+        return { ...target, served: { ...target.served, artifact } };
+    }
+    async doctor(id, req) {
+        const binding = await this.channels.internal(id);
+        const checks = [];
+        const check = async (name, work) => {
+            try {
+                await work();
+                checks.push({ name, status: 'ready' });
+            }
+            catch (error) {
+                checks.push({
+                    name,
+                    status: 'unavailable',
+                    code: error instanceof ChannelError ? error.code : 'check_unavailable',
+                });
+            }
+        };
+        await check('durability', async () => {
+            if (!this.options.store.durable)
+                throw new ChannelError('durable_storage_required');
+        });
+        await check('worker', async () => {
+            if (!this.options.worker.ready())
+                throw new ChannelError('worker_unavailable');
+        });
+        await check('deployment', async () => {
+            await this.target(binding);
+        });
+        await check('model_cost', async () => {
+            const model = await resolveAssistantModelBinding(await this.target(binding), binding.tenant, binding.deploymentId, this.deps, 'whatsapp');
+            if (!model)
+                throw new ChannelError('model_not_configured');
+            verifiedInferenceBound(model, this.channels.now());
+        });
+        await check('history_policy', async () => {
+            await this.retention(binding);
+        });
+        await check('knowledge', async () => {
+            const target = await this.target(binding);
+            if ((target.served.artifact.server.knowledge?.length ?? 0) > 0 &&
+                !(await resolveAssistantKnowledge(target.served)))
+                throw new ChannelError('knowledge_unavailable');
+        });
+        await check('provider_asset', async () => {
+            const health = await (await this.provider(binding)).adapter.health();
+            if (health.phoneNumberId !== binding.phoneNumberId)
+                throw new ChannelError('asset_mismatch');
+            if (!health.canSend)
+                throw new ChannelError('provider_messaging_unavailable');
+        });
+        await check('webhook', async () => {
+            const state = await this.webhook(id, req);
+            if (!state.matches || !state.authenticated)
+                throw new ChannelError('webhook_not_configured');
+        });
+        const ready = checks.every((check) => check.status === 'ready');
+        if (ready)
+            await this.channels.markReady(id, binding.revision);
+        return { ready, revision: binding.revision, checks, webhookUrl: this.webhookUrl(req, binding) };
+    }
+    async webhook(id, req) {
+        const binding = await this.channels.internal(id);
+        const { adapter, webhookSecret } = await this.provider(binding);
+        const current = await adapter.webhook();
+        return {
+            url: this.webhookUrl(req, binding),
+            matches: current.url === this.webhookUrl(req, binding),
+            authenticated: verifyWhatsAppWebhookSecret(current.headers?.[WHATSAPP_CALLBACK_HEADER], webhookSecret),
+        };
+    }
+    async configureWebhook(id, req) {
+        const binding = await this.channels.internal(id);
+        if (binding.state !== 'paused')
+            throw new ChannelError('pause_before_webhook_change');
+        const { adapter, webhookSecret } = await this.provider(binding);
+        const existing = await adapter.webhook();
+        const url = this.webhookUrl(req, binding);
+        if (existing.url && existing.url !== url)
+            throw new ChannelError('webhook_ownership_conflict');
+        if (existing.url !== url ||
+            !verifyWhatsAppWebhookSecret(existing.headers?.[WHATSAPP_CALLBACK_HEADER], webhookSecret))
+            await adapter.configureWebhook(url, webhookSecret);
+    }
+    async projection(tenant) {
+        const binding = await this.channels.get(tenant);
+        if (!binding)
+            return {
+                status: 'unavailable',
+                capabilities: [],
+                reason: 'WhatsApp is not configured.',
+            };
+        const view = {
+            bindingId: binding.id,
+            revision: binding.revision,
+            capabilities: binding.capabilities.map((cap) => `${cap.kind}:${cap.name}`),
+        };
+        if (binding.state !== 'enabled')
+            return { ...view, status: 'paused' };
+        try {
+            await this.target(await this.channels.internal(binding.id));
+            return { ...view, status: 'ready' };
+        }
+        catch {
+            return {
+                ...view,
+                status: 'unavailable',
+                reason: 'The active deployment or installation is unavailable.',
+            };
+        }
+    }
+    async providerBlock(id, participantId, blocked, actor, key, protectedPhone) {
+        const operation = await beginChannelProviderBlock(this.channels.store, id, participantId, blocked ? 'blocked' : 'unblocked', actor, key, this.channels.now(), protectedPhone);
+        if (!operation)
+            return;
+        try {
+            const binding = await this.channels.internal(id);
+            if (binding.generation !== operation.generation)
+                throw new ChannelError('authority_changed');
+            const { adapter } = await this.provider(binding);
+            const result = await adapter.setBlocked(operation.address.value, blocked);
+            await finishChannelProviderBlock(this.channels.store, id, participantId, operation.revision, result.state, this.channels.now(), result.code);
+        }
+        catch {
+            await finishChannelProviderBlock(this.channels.store, id, participantId, operation.revision, 'unknown', this.channels.now(), 'provider_outcome_unknown');
+        }
+    }
+    async blocks(id, after) {
+        const local = await this.channels.blocks(id, after);
+        const provider = await channelProviderBlocks(this.channels.store, id, this.channels.now(), after);
+        const ids = [
+            ...new Set([
+                ...local.map((item) => item.participantId),
+                ...provider.map((item) => item.participantId),
+            ]),
+        ];
+        const data = ids
+            .sort()
+            .slice(0, 100)
+            .map((participantId) => {
+            const block = local.find((item) => item.participantId === participantId);
+            const match = provider.find((item) => item.participantId === participantId);
+            return {
+                ...(block ?? {
+                    participantId,
+                    actor: match.actor,
+                    reason: 'operator',
+                    until: null,
+                }),
+                local: !!block && (block.until === null || block.until > this.channels.now()),
+                ...(match
+                    ? {
+                        provider: {
+                            desired: match.desired,
+                            state: match.state,
+                            updatedAt: match.updatedAt,
+                            ...(match.code ? { code: match.code } : {}),
+                        },
+                    }
+                    : {}),
+            };
+        });
+        return { data, ...(data.length === 100 ? { next: data.at(-1).participantId } : {}) };
+    }
+    async retention(binding) {
+        const days = (await this.options.historyDays?.(binding.tenant)) ?? 7;
+        if (!Number.isInteger(days) || days < 1)
+            throw new ChannelError('history_policy_unavailable');
+        return Math.min(CHANNEL_RETENTION_MS, days * 86_400_000);
+    }
+    async sweep() {
+        const page = await this.channels.bindingPage(this.cursor);
+        this.cursor = page.after;
+        // Bounded parallelism and rotating registry pages prevent a busy tenant starving later ones.
+        for (let offset = 0; offset < page.ids.length; offset += 5) {
+            await Promise.all(page.ids.slice(offset, offset + 5).map((id) => this.process(id)));
+        }
+        await this.options.store.prune(this.channels.now(), 1000);
+    }
+    async process(id) {
+        try {
+            if (this.options.worker.signal.aborted)
+                return;
+            const binding = await this.channels.internal(id);
+            const retention = await this.retention(binding);
+            await this.channels.expireHistory(id, retention);
+            const work = await this.channels.claim(id, retention);
+            if (work)
+                await this.answer(work);
+            for (let n = 0; n < 5 && !this.options.worker.signal.aborted; n++) {
+                const send = await this.channels.prepareSend(id);
+                if (!send)
+                    break;
+                await this.target(await this.channels.internal(id));
+                const { adapter } = await this.provider(send.binding);
+                await this.channels.assertSend(id, send.event.id, send.event.lease);
+                this.options.worker.signal.throwIfAborted();
+                await this.channels.sent(id, send.event.id, send.event.lease, await adapter.send({ to: send.participant.address, text: send.event.reply }));
+            }
+        }
+        catch {
+            this.deps.logger?.warn('assistant.channel.worker', { code: 'channel_work_failed' });
+        }
+    }
+    async answer(work) {
+        const { binding, participant, event } = work;
+        const abort = new AbortController();
+        const signal = AbortSignal.any([
+            abort.signal,
+            this.options.worker.signal,
+            AbortSignal.timeout(60_000),
+        ]);
+        const historyRetention = await this.retention(binding);
+        const beforeStep = async () => {
+            if ((await this.retention(binding)) !== historyRetention)
+                throw new ChannelError('history_policy_changed');
+            signal.throwIfAborted();
+            await this.provider(await this.channels.internal(binding.id));
+            await this.channels.renew(binding.id, event.id, event.lease);
+            await this.target(await this.channels.internal(binding.id));
+        };
+        const timer = setInterval(() => {
+            void beforeStep().catch(() => abort.abort());
+        }, 10_000);
+        timer.unref?.();
+        try {
+            const target = await this.target(binding);
+            const model = await resolveAssistantModelBinding(target, binding.tenant, binding.deploymentId, this.deps, 'whatsapp');
+            if (!model)
+                throw new ChannelError('model_not_configured');
+            const session = {
+                kind: 'messaging',
+                channel: 'whatsapp',
+                id: event.id,
+                bindingId: binding.id,
+                participantId: participant.id,
+                tenant: binding.tenant,
+                deploymentId: binding.deploymentId,
+                caller: { identityKind: 'anonymous', subject: participant.id, roles: [], scopes: [] },
+                history: participant.history.map(({ role, content }) => ({ role, content })),
+                modelToolUses: participant.modelToolUses ?? [],
+            };
+            const context = await resolveInvocationContextSnapshot({
+                artifact: target.served.artifact,
+                executeDeps: withAssistantTurnExecutionAuthority({ ...target.served.deps, signal }, target.served.artifact, session),
+                caller: session.caller,
+                instant: new Date(this.channels.now()),
+            });
+            let text = '', failure;
+            await runAgentTurn(target, session, event.text, context, this.deps, (result) => {
+                if (result.event === 'content' && typeof result.data.delta === 'string')
+                    text += result.data.delta;
+                if (result.event === 'error')
+                    failure = String(result.data.code ?? 'answer_failed');
+            }, undefined, undefined, undefined, false, {
+                binding: withChannelInferenceGuard(model, this.channels, binding.id, event.id, beforeStep),
+                beforeStep,
+                claimTool: (name) => this.channels.claimTool(binding.id, participant.id, name),
+                signal,
+            });
+            if (failure || !text.trim())
+                throw new ChannelError(failure ?? 'answer_unavailable');
+            const disclosure = participant.history.length === 0
+                ? `I’m ${target.served.artifact.server.branding?.name ?? target.served.artifact.server.title}’s AI assistant.\n\n`
+                : '';
+            const answer = disclosure + text.trim();
+            const bounded = answer.length <= 3500
+                ? answer
+                : `${answer.slice(0, 3350).replace(/[\uD800-\uDBFF]$/u, '')}\n\nAsk me to expand on any part.`;
+            await this.channels.complete(binding.id, event.id, event.lease, bounded, historyRetention);
+        }
+        catch (error) {
+            const code = error instanceof ChannelError ? error.code : 'answer_failed';
+            try {
+                await this.channels.complete(binding.id, event.id, event.lease, `I couldn’t complete that request. For help, contact ${binding.supportEmail}.`, historyRetention, code);
+            }
+            catch {
+                await this.channels.fail(binding.id, event.id, event.lease, code);
+            }
+        }
+        finally {
+            clearInterval(timer);
+        }
+    }
+}
+//# sourceMappingURL=runtime.js.map

package/node_modules/@noodle-borg/service/dist/channels/worker-loop.js

@@ -0,0 +1,50 @@
+/** A process scheduler, never the owner of acknowledged work. PostgreSQL leases own recovery. */
+export class ChannelWorkerLoop {
+    onError;
+    run;
+    timer;
+    running;
+    stopped = true;
+    tickAt = 0;
+    abort = new AbortController();
+    get signal() {
+        return this.abort.signal;
+    }
+    constructor(onError = () => undefined) {
+        this.onError = onError;
+    }
+    attach(run) {
+        this.run = run;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.stopped = false;
+        this.abort = new AbortController();
+        this.timer = setInterval(() => this.wake(), 1000);
+        this.timer.unref?.();
+        this.wake();
+    }
+    ready() {
+        return !this.stopped && !!this.run && Date.now() - this.tickAt < 90_000;
+    }
+    wake() {
+        if (this.stopped || this.running || !this.run)
+            return;
+        this.tickAt = Date.now();
+        this.running = this.run()
+            .catch(() => this.onError('channel_worker_failed'))
+            .finally(() => {
+            this.running = undefined;
+        });
+    }
+    async stop() {
+        this.stopped = true;
+        this.abort.abort();
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        await this.running;
+    }
+}
+//# sourceMappingURL=worker-loop.js.map

package/node_modules/@noodle-borg/service/dist/routes/assistant-agent.js

@@ -1,6 +1,6 @@
 import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
 import { assistantCoreModelMessages, assistantTurnModelContextMessages, requestAssistantSuggestedPrompts, requestModelCompletion, resolveAssistantContextProviderModelResult, } from '@noodle-borg/assistant-gateway/model-runtime';
-import { assistantGuideModelContext, assistantModelToolOncePerSession, assistantModelToolRequiredWhenVisible, assistantOmittedToolResult, assistantViewAvailableData, dispatchAssistantTool, projectAssistantGuide, publicSurfaceOf, recoverableAssistantView, remainingTurnTokens, selectAssistantModelTools, toolTouchesDelegatedAuth, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { assistantGuideModelContext, assistantModelToolOncePerSession, assistantModelToolRequiredWhenVisible, assistantOmittedToolResult, assistantViewAvailableData, dispatchAssistantTool, dispatchMessagingReadTool, isMessagingTurn, projectAssistantGuide, publicSurfaceOf, recoverableAssistantView, remainingTurnTokens, selectAssistantModelTools, toolTouchesDelegatedAuth, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
 import { guardedFetch } from '@noodle-borg/connector-http';
 import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
@@ -34,14 +34,15 @@ export function createAssistantTurnStats() {
     };
 }
 /** Run one model/tool loop against the immutable invocation-context snapshot for this turn. */
-export async function runAgentTurn(target, session, message, context, deps, emit, modelContext, pageContext, stats = createAssistantTurnStats(), suggestions = false) {
+export async function runAgentTurn(target, session, message, context, deps, emit, modelContext, pageContext, stats = createAssistantTurnStats(), suggestions = false, transport) {
     // Every terminal failure in this loop is one shape: a code, and the turn ends. Naming it keeps the
     // dozen sites readable and stops a new one inventing a different envelope.
     const fail = (code) => emit({ event: 'error', data: { code } });
     const assistant = target.served.artifact.server.assistant;
     if (!assistant)
         return fail('assistant_unavailable');
-    const binding = await resolveAssistantModelBinding(target, session.tenant, session.deploymentId, deps);
+    const binding = transport?.binding ??
+        (await resolveAssistantModelBinding(target, session.tenant, session.deploymentId, deps));
     if (!binding) {
         return emit({
             event: 'error',
@@ -106,6 +107,8 @@ export async function runAgentTurn(target, session, message, context, deps, emit
         ? undefined
         : AbortSignal.timeout(binding.requestPolicy.maxTurnMs);
     for (let step = 0; step < bounds.steps; step += 1) {
+        await transport?.beforeStep();
+        transport?.signal.throwIfAborted();
         if (remainingTokens !== undefined && remainingTokens <= 0)
             return fail('model_token_budget_exhausted');
         const requestTokenLimit = Math.min(binding.requestPolicy?.maxCompletionTokens ?? Number.MAX_SAFE_INTEGER, remainingTokens ?? Number.MAX_SAFE_INTEGER);
@@ -118,7 +121,11 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                 streamedContent += delta;
                 emit({ event: 'content', data: { delta } });
             }
-            : () => undefined, requiredToolForStep === undefined ? assistantKnowledgeModelTools(knowledge) : [], stepModelTools, requestTokenLimit === Number.MAX_SAFE_INTEGER ? undefined : requestTokenLimit, turnSignal, requiredToolForStep === undefined ? undefined : 'required');
+            : () => undefined, requiredToolForStep === undefined ? assistantKnowledgeModelTools(knowledge) : [], stepModelTools, requestTokenLimit === Number.MAX_SAFE_INTEGER ? undefined : requestTokenLimit, transport
+            ? turnSignal
+                ? AbortSignal.any([transport.signal, turnSignal])
+                : transport.signal
+            : turnSignal, requiredToolForStep === undefined ? undefined : 'required');
         stats.promptTokens += completion.usage?.promptTokens ?? 0;
         stats.completionTokens += completion.usage?.completionTokens ?? 0;
         stats.reasoningTokens += completion.usage?.reasoningTokens ?? 0;
@@ -137,7 +144,10 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             const assistantContent = response.content || streamedContent;
             if (assistantContent)
                 messages.push({ role: 'assistant', content: assistantContent });
-            if (suggestions && step + 1 < bounds.steps && (remainingTokens ?? 1) > 0) {
+            if (!isMessagingTurn(session) &&
+                suggestions &&
+                step + 1 < bounds.steps &&
+                (remainingTokens ?? 1) > 0) {
                 try {
                     const prompts = await requestAssistantSuggestedPrompts(binding, messages, assistantModelFetcher(deps.modelFetch), stats, remainingTokens, turnSignal);
                     if (prompts.length > 0) {
@@ -164,6 +174,7 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             stats.toolCalls += 1;
             if (toolCallsThisTurn > bounds.toolCalls)
                 return fail('tool_call_budget_exhausted');
+            await transport?.beforeStep();
             const knowledgeComponent = findAssistantKnowledgeComponent(knowledge, call.function.name);
             if (knowledge !== undefined && knowledgeComponent !== undefined) {
                 let knowledgeArgs;
@@ -205,21 +216,23 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             // The hosted broker exposes its delegated binding keys so the intercept can classify on
             // connector auth kind too; a broker without the method leaves the base classification alone.
             const delegatedKeys = target.served.deps.broker.assistantDelegatedAuthKeys?.();
-            const elevation = await interceptForElevation({
-                tool,
-                session,
-                assistant,
-                ...(target.served.artifact.server.state === undefined
-                    ? {}
-                    : { state: target.served.artifact.server.state }),
-                elevations: deps.elevations,
-                ...(delegatedKeys !== undefined && delegatedKeys.size > 0
-                    ? {
-                        requiresDelegatedIdentity: (candidate) => toolTouchesDelegatedAuth(candidate, delegatedKeys),
-                    }
-                    : {}),
-                now: deps.clock?.() ?? new Date(),
-            });
+            const elevation = isMessagingTurn(session)
+                ? undefined
+                : await interceptForElevation({
+                    tool,
+                    session,
+                    assistant,
+                    ...(target.served.artifact.server.state === undefined
+                        ? {}
+                        : { state: target.served.artifact.server.state }),
+                    elevations: deps.elevations,
+                    ...(delegatedKeys !== undefined && delegatedKeys.size > 0
+                        ? {
+                            requiresDelegatedIdentity: (candidate) => toolTouchesDelegatedAuth(candidate, delegatedKeys),
+                        }
+                        : {}),
+                    now: deps.clock?.() ?? new Date(),
+                });
             if (elevation) {
                 stats.interactionCount += 1;
                 emit(elevation.event);
@@ -245,19 +258,34 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             if (coerced.issues.length > 0)
                 return fail('invalid_tool_arguments');
             args = coerced.value;
-            const dispatch = await dispatchAssistantTool({
-                artifact: target.served.artifact,
-                tool,
-                arguments: args,
-                executeDeps: withAssistantSessionExecutionAuthority({ ...target.served.deps, capabilityBudget }, target.served.artifact, session),
-                caller: session.caller,
-                context,
-                session,
-                store: deps.store,
-                audit: deps.audit,
-                now: () => deps.clock?.() ?? new Date(),
-                onToolStarted: () => emit({ event: 'tool_started', data: { id: call.id, tool: tool.name } }),
-            });
+            await transport?.beforeStep();
+            const dispatch = isMessagingTurn(session)
+                ? await dispatchMessagingReadTool({
+                    artifact: target.served.artifact,
+                    tool,
+                    arguments: args,
+                    executeDeps: {
+                        ...target.served.deps,
+                        capabilityBudget,
+                        ...(transport?.signal ? { signal: transport.signal } : {}),
+                    },
+                    context,
+                    session,
+                    claimTool: transport?.claimTool ?? (async () => false),
+                })
+                : await dispatchAssistantTool({
+                    artifact: target.served.artifact,
+                    tool,
+                    arguments: args,
+                    executeDeps: withAssistantSessionExecutionAuthority({ ...target.served.deps, capabilityBudget }, target.served.artifact, session),
+                    caller: session.caller,
+                    context,
+                    session,
+                    store: deps.store,
+                    audit: deps.audit,
+                    now: () => deps.clock?.() ?? new Date(),
+                    onToolStarted: () => emit({ event: 'tool_started', data: { id: call.id, tool: tool.name } }),
+                });
             if (assistantModelToolOncePerSession(tool) &&
                 (dispatch.kind !== 'event' || dispatch.event !== 'error')) {
                 modelTools = modelTools.filter((candidate) => candidate.name !== tool.name);
@@ -274,7 +302,7 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                 result: dispatch.output,
                 arguments: args,
             }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }));
-            if (view) {
+            if (view && !isMessagingTurn(session)) {
                 if (!dispatch.ephemeral)
                     await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
                 emit({ event: 'view_available', data: { ...view } });

package/node_modules/@noodle-borg/service/dist/routes/assistant-model-binding.js

@@ -1,11 +1,15 @@
 import { resolveManagedVariablesInString } from '../managed-config-expressions.js';
 import { resolveConfigScope } from '../store.js';
-export async function resolveAssistantModelBinding(target, tenant, deploymentId, deps) {
+export async function resolveAssistantModelBinding(target, tenant, deploymentId, deps, channel) {
     const declaration = target.served.artifact.server.assistant?.model;
     if (declaration === undefined)
         return undefined;
     if (declaration.kind === 'noodle-managed') {
-        return deps.managedModelResolver?.resolve({ tenant, deploymentId });
+        return deps.managedModelResolver?.resolve({
+            tenant,
+            deploymentId,
+            ...(channel ? { channel } : {}),
+        });
     }
     const scope = resolveConfigScope(tenant);
     const [variables, secrets] = await Promise.all([

package/node_modules/@noodle-borg/service/dist/routes/business-information-channels.js

@@ -59,7 +59,20 @@ export async function projectBusinessChannels(installation, canEdit, base, deps)
     };
     const registered = await deps.registry.getActiveByTenant(tenant);
     const target = registered && (await resolveTargetOrigins(registered));
-    const shared = { revision: installation.revision, active: installation.intakeActive, canEdit };
+    const whatsapp = await deps.readWhatsApp?.(tenant);
+    const shared = {
+        revision: installation.revision,
+        active: installation.intakeActive,
+        canEdit,
+        ...(whatsapp
+            ? {
+                whatsapp: {
+                    ...whatsapp,
+                    ...(!installation.intakeActive ? { status: 'paused' } : {}),
+                },
+            }
+            : {}),
+    };
     if (!target?.deploymentId)
         return {
             ...shared,