@rudderhq/server 0.1.0-canary.0

package/dist/services/chat-assistant.js

@@ -0,0 +1,943 @@
+import { randomUUID } from "node:crypto";
+import { findServerAdapter } from "../agent-runtimes/index.js";
+import { agentRunContextService, RUDDER_COPILOT_LABEL } from "./agent-run-context.js";
+import { agentService } from "./agents.js";
+import { organizationService } from "./orgs.js";
+const ORGANIZATION_DEFAULT_CHAT_ADAPTER_TYPES = new Set([
+    "claude_local",
+    "codex_local",
+    "cursor",
+    "gemini_local",
+    "opencode_local",
+    "pi_local",
+    "openclaw_gateway",
+]);
+const CHAT_UNSUPPORTED_ADAPTER_TYPES = new Set(["process", "http"]);
+const CHAT_RESULT_SENTINEL_PREFIX = "__RUDDER_RESULT_";
+export class ChatAssistantStreamError extends Error {
+    partialBody;
+    constructor(message, partialBody) {
+        super(message);
+        this.name = "ChatAssistantStreamError";
+        this.partialBody = partialBody;
+    }
+}
+function safeTrim(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function modelLabel(config) {
+    return safeTrim(typeof config?.model === "string" ? config.model : null);
+}
+function unconfiguredDescriptor(error) {
+    return {
+        sourceType: "unconfigured",
+        sourceLabel: "Configure Rudder Copilot",
+        runtimeAgentId: null,
+        agentRuntimeType: null,
+        model: null,
+        available: false,
+        error,
+    };
+}
+function unavailableAgentDescriptor(input) {
+    return {
+        sourceType: "agent",
+        sourceLabel: input.sourceLabel,
+        runtimeAgentId: input.runtimeAgentId,
+        agentRuntimeType: input.agentRuntimeType,
+        model: input.model,
+        available: false,
+        error: input.error,
+    };
+}
+function buildPrompt(input) {
+    const contextSummary = input.contextLinks.map((link) => ({
+        entityType: link.entityType,
+        entityId: link.entityId,
+        label: link.entity?.label ?? null,
+        identifier: link.entity?.identifier ?? null,
+        status: link.entity?.status ?? null,
+    }));
+    const history = input.messages.slice(-12).map((message) => ({
+        role: message.role,
+        kind: message.kind,
+        status: message.status,
+        body: message.body,
+        structuredPayload: message.structuredPayload,
+    }));
+    return JSON.stringify({
+        conversation: {
+            id: input.conversation.id,
+            title: input.conversation.title,
+            status: input.conversation.status,
+            summary: input.conversation.summary,
+            planMode: input.conversation.planMode,
+            issueCreationMode: input.conversation.issueCreationMode,
+            preferredAgentId: input.conversation.preferredAgentId,
+            routedAgentId: input.conversation.routedAgentId,
+            primaryIssueId: input.conversation.primaryIssueId,
+        },
+        contextLinks: contextSummary,
+        recentMessages: history,
+    }, null, 2);
+}
+function buildOperatorProfilePromptSection(profile) {
+    const nickname = safeTrim(profile?.nickname);
+    const moreAboutYou = safeTrim(profile?.moreAboutYou);
+    if (!nickname && !moreAboutYou)
+        return null;
+    return [
+        "Current board operator profile:",
+        ...(nickname ? [`- Preferred form of address: ${nickname}`] : []),
+        ...(moreAboutYou ? [`- Background about the operator: ${moreAboutYou}`] : []),
+        "Use this only as background context when you address the operator or interpret their requests.",
+    ].join("\n");
+}
+function buildChatSpeakerPromptSection(runtimeSource) {
+    const name = runtimeSource.descriptor.sourceLabel;
+    if (runtimeSource.descriptor.sourceType === "agent") {
+        return [
+            `You are ${name}, replying inside Rudder's chat scene.`,
+            "Speak as this agent, using the agent's own instructions and enabled skills as your working context.",
+            "Do not claim to be Rudder Copilot or a generic assistant.",
+        ].join("\n");
+    }
+    return [
+        `You are ${name}, the system-managed chat copilot for this Rudder organization.`,
+        "Stay inside the chat scene. Clarify, structure, and propose work, but do not hand off or dispatch to another agent on your own.",
+    ].join("\n");
+}
+function buildBaseSystemPromptSections(runtimeSource, resultSentinel) {
+    return [
+        buildChatSpeakerPromptSection(runtimeSource),
+        "Your job is to clarify work requests for a Rudder AI organization control plane.",
+        "This is the dedicated chat scene. Do not use heartbeat issue bootstrap framing.",
+        "Always reply in the same language as the user's most recent substantive message unless they explicitly ask for a different language.",
+        "Always prefer clarification before proposing issue creation when requirements are incomplete.",
+        "Use result kind 'message' for clarification, summaries, and small requests that can stay in chat.",
+        "Use result kind 'issue_proposal' for larger work that should become an issue.",
+        "Use result kind 'routing_suggestion' only when recommending an agent or role to handle work.",
+        "Reply in two phases.",
+        "Phase 1: write the user-visible reply in Markdown with no JSON fences.",
+        `Phase 2: on a new line, emit exactly ${resultSentinel} followed immediately by one JSON object.`,
+        "Do not output anything after that JSON object.",
+    ];
+}
+function buildPlanModePromptSection() {
+    return [
+        "Plan mode is active for this conversation.",
+        "Stay strictly in read-only investigation and planning mode.",
+        "Do not propose or imply file edits, shell mutations, or lightweight control-plane changes.",
+        "Converge on an issue-sized implementation plan, and when you are ready to conclude, emit kind 'issue_proposal'.",
+        "Include structuredPayload.planDocument.body as markdown for the issue plan document.",
+    ].join("\n");
+}
+function buildResponseSchemaPromptSection(planMode) {
+    return [
+        "JSON shape:",
+        JSON.stringify({
+            kind: "message",
+            body: "same visible reply, summarized if needed",
+            structuredPayload: {
+                summary: "optional short summary",
+                issueProposal: {
+                    title: "required for issue_proposal",
+                    description: "required for issue_proposal",
+                    priority: "critical|high|medium|low",
+                    assigneeAgentId: "optional uuid",
+                    projectId: "optional uuid",
+                    goalId: "optional uuid",
+                    parentId: "optional uuid",
+                },
+                planDocument: {
+                    title: "optional plan title",
+                    body: planMode
+                        ? "required markdown plan for the issue plan document"
+                        : "optional markdown plan",
+                    changeSummary: "optional short summary for the issue document revision",
+                },
+                routingSuggestion: {
+                    agentId: "optional uuid",
+                    reason: "short explanation",
+                },
+            },
+        }, null, 2),
+    ].join("\n");
+}
+function systemPrompt(runtimeSource, conversation, resultSentinel) {
+    return [
+        ...buildBaseSystemPromptSections(runtimeSource, resultSentinel),
+        ...(conversation.planMode ? [buildPlanModePromptSection()] : []),
+        buildResponseSchemaPromptSection(conversation.planMode),
+    ].join("\n");
+}
+function extractJsonObject(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Fall through to brace matching.
+    }
+    const firstBrace = trimmed.indexOf("{");
+    const lastBrace = trimmed.lastIndexOf("}");
+    if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed.slice(firstBrace, lastBrace + 1));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function validateAssistantResult(payload, options = {}) {
+    const kind = typeof payload.kind === "string" ? payload.kind : "message";
+    const payloadBody = typeof payload.body === "string" ? payload.body.trim() : "";
+    const body = options.bodyOverride?.trim() || payloadBody;
+    const structuredPayload = payload.structuredPayload && typeof payload.structuredPayload === "object" && !Array.isArray(payload.structuredPayload)
+        ? payload.structuredPayload
+        : null;
+    if (!body) {
+        throw new Error("Assistant response body was empty");
+    }
+    if (kind !== "message" &&
+        kind !== "issue_proposal" &&
+        kind !== "operation_proposal" &&
+        kind !== "routing_suggestion") {
+        throw new Error(`Unsupported assistant result kind: ${kind}`);
+    }
+    return {
+        kind,
+        body,
+        structuredPayload,
+    };
+}
+function buildConversationPrompt(input, runtimeSource, resultSentinel, orgResourcesPrompt) {
+    const operatorProfileSection = buildOperatorProfilePromptSection(input.operatorProfile);
+    /**
+     * Chat prompt assembly stays compositional on purpose.
+     *
+     * Reasoning:
+     * - Always-loaded sections should hold only invariant chat-scene rules.
+     * - Conditional behavior such as plan mode should be injected only when active,
+     *   so the runtime does not carry dormant "when X, do Y" branches in every chat.
+     *
+     * Traceability:
+     * - doc/plans/2026-04-18-chat-plan-mode.md
+     * - doc/DEVELOPING.md
+     */
+    return [
+        systemPrompt(runtimeSource, input.conversation, resultSentinel),
+        ...(orgResourcesPrompt ? [orgResourcesPrompt] : []),
+        ...(operatorProfileSection ? [operatorProfileSection] : []),
+        "Conversation input:",
+        buildPrompt(input),
+    ].join("\n\n");
+}
+function resultText(result) {
+    if (typeof result.summary === "string" && result.summary.trim().length > 0) {
+        return result.summary.trim();
+    }
+    const raw = result.resultJson && typeof result.resultJson === "object" && !Array.isArray(result.resultJson)
+        ? result.resultJson
+        : null;
+    const candidate = typeof raw?.text === "string"
+        ? raw.text
+        : typeof raw?.message === "string"
+            ? raw.message
+            : typeof raw?.content === "string"
+                ? raw.content
+                : null;
+    return safeTrim(candidate) ?? "";
+}
+function configArgs(agentRuntimeConfig) {
+    const raw = Array.isArray(agentRuntimeConfig.extraArgs)
+        ? agentRuntimeConfig.extraArgs
+        : Array.isArray(agentRuntimeConfig.args)
+            ? agentRuntimeConfig.args
+            : [];
+    return raw.filter((value) => typeof value === "string" && value.trim().length > 0);
+}
+function stripCliArgs(args, input) {
+    const flagsWithValues = new Set(input.flagsWithValues ?? []);
+    const standaloneFlags = new Set(input.standaloneFlags ?? []);
+    const prefixedFlags = input.prefixedFlags ?? [];
+    const next = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (flagsWithValues.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (standaloneFlags.has(arg)) {
+            continue;
+        }
+        if (prefixedFlags.some((prefix) => arg.startsWith(prefix))) {
+            continue;
+        }
+        next.push(arg);
+    }
+    return next;
+}
+function applyPlanModeRuntimeOverlay(agentRuntimeType, agentRuntimeConfig) {
+    const args = configArgs(agentRuntimeConfig);
+    if (agentRuntimeType === "codex_local") {
+        return {
+            ...agentRuntimeConfig,
+            dangerouslyBypassApprovalsAndSandbox: false,
+            dangerouslyBypassSandbox: false,
+            extraArgs: [
+                "-s",
+                "read-only",
+                ...stripCliArgs(args, {
+                    flagsWithValues: ["-s", "--sandbox"],
+                    standaloneFlags: ["--dangerously-bypass-approvals-and-sandbox"],
+                    prefixedFlags: ["--sandbox="],
+                }),
+            ],
+        };
+    }
+    if (agentRuntimeType === "claude_local") {
+        return {
+            ...agentRuntimeConfig,
+            dangerouslySkipPermissions: false,
+            extraArgs: [
+                "--permission-mode",
+                "plan",
+                ...stripCliArgs(args, {
+                    flagsWithValues: ["--permission-mode"],
+                    standaloneFlags: ["--dangerously-skip-permissions"],
+                    prefixedFlags: ["--permission-mode="],
+                }),
+            ],
+        };
+    }
+    if (agentRuntimeType === "cursor") {
+        return {
+            ...agentRuntimeConfig,
+            mode: "plan",
+            extraArgs: stripCliArgs(args, {
+                flagsWithValues: ["--mode"],
+                prefixedFlags: ["--mode="],
+            }),
+        };
+    }
+    return agentRuntimeConfig;
+}
+function chatExecutionConfig(conversation, agentRuntimeType, agentRuntimeConfig) {
+    const baseConfig = conversation.planMode
+        ? applyPlanModeRuntimeOverlay(agentRuntimeType, agentRuntimeConfig)
+        : agentRuntimeConfig;
+    return {
+        ...baseConfig,
+        promptTemplate: "{{context.chatPrompt}}",
+        bootstrapPromptTemplate: "",
+        maxTurns: 1,
+        chrome: false,
+    };
+}
+function linkedIssueIdsForChat(conversation, contextLinks) {
+    return Array.from(new Set([
+        conversation.primaryIssueId,
+        ...contextLinks
+            .filter((link) => link.entityType === "issue")
+            .map((link) => link.entityId),
+    ].filter((value) => typeof value === "string" && value.trim().length > 0)));
+}
+function linkedProjectIdForChat(contextLinks) {
+    return contextLinks.find((link) => link.entityType === "project")?.entityId ?? null;
+}
+function stubAgent(input) {
+    return {
+        id: input.sourceId,
+        orgId: input.orgId,
+        name: input.sourceLabel,
+        agentRuntimeType: input.agentRuntimeType,
+        agentRuntimeConfig: input.agentRuntimeConfig,
+    };
+}
+function summarizeRuntimeSkills(entries) {
+    return entries.map((entry) => ({
+        key: entry.key,
+        runtimeName: entry.runtimeName,
+        name: entry.name,
+        description: entry.description,
+    }));
+}
+function longestSentinelPrefixSuffix(value, sentinel) {
+    const max = Math.min(value.length, sentinel.length - 1);
+    for (let len = max; len > 0; len -= 1) {
+        if (value.endsWith(sentinel.slice(0, len))) {
+            return len;
+        }
+    }
+    return 0;
+}
+function createAssistantTextAccumulator() {
+    let fullText = "";
+    return {
+        get fullText() {
+            return fullText;
+        },
+        push(fragment, isDelta = false) {
+            if (!fragment)
+                return "";
+            if (isDelta) {
+                fullText += fragment;
+                return fragment;
+            }
+            if (fragment.startsWith(fullText)) {
+                const delta = fragment.slice(fullText.length);
+                fullText = fragment;
+                return delta;
+            }
+            if (fullText.endsWith(fragment) || fullText.includes(fragment)) {
+                return "";
+            }
+            fullText += fragment;
+            return fragment;
+        },
+    };
+}
+function createSentinelStream(resultSentinel) {
+    let visibleText = "";
+    let resultPayloadText = "";
+    let carry = "";
+    let seenSentinel = false;
+    return {
+        get visibleText() {
+            return visibleText;
+        },
+        get resultPayloadText() {
+            return resultPayloadText;
+        },
+        get seenSentinel() {
+            return seenSentinel;
+        },
+        push(text) {
+            if (!text)
+                return "";
+            if (seenSentinel) {
+                resultPayloadText += text;
+                return "";
+            }
+            const combined = `${carry}${text}`;
+            const sentinelIndex = combined.indexOf(resultSentinel);
+            if (sentinelIndex >= 0) {
+                const visibleDelta = combined.slice(0, sentinelIndex);
+                seenSentinel = true;
+                visibleText += visibleDelta;
+                resultPayloadText += combined.slice(sentinelIndex + resultSentinel.length);
+                carry = "";
+                return visibleDelta;
+            }
+            const holdLength = longestSentinelPrefixSuffix(combined, resultSentinel);
+            const visibleDelta = combined.slice(0, combined.length - holdLength);
+            carry = combined.slice(combined.length - holdLength);
+            visibleText += visibleDelta;
+            return visibleDelta;
+        },
+        finish() {
+            if (seenSentinel) {
+                if (carry)
+                    resultPayloadText += carry;
+                carry = "";
+                return "";
+            }
+            const visibleDelta = carry;
+            carry = "";
+            visibleText += visibleDelta;
+            return visibleDelta;
+        },
+    };
+}
+function parseAssistantEnvelope(rawText, resultSentinel) {
+    const sentinelIndex = rawText.indexOf(resultSentinel);
+    if (sentinelIndex === -1) {
+        return {
+            visibleBody: rawText.trim(),
+            jsonPayload: null,
+            usedSentinel: false,
+        };
+    }
+    const visibleBody = rawText.slice(0, sentinelIndex).trim();
+    const jsonPayload = extractJsonObject(rawText.slice(sentinelIndex + resultSentinel.length));
+    return {
+        visibleBody,
+        jsonPayload,
+        usedSentinel: true,
+    };
+}
+function parseCompletedAssistantReply(rawText, resultSentinel) {
+    const enveloped = parseAssistantEnvelope(rawText, resultSentinel);
+    if (enveloped.jsonPayload) {
+        return validateAssistantResult(enveloped.jsonPayload, {
+            bodyOverride: enveloped.usedSentinel ? enveloped.visibleBody : null,
+        });
+    }
+    const legacyPayload = extractJsonObject(rawText);
+    if (legacyPayload) {
+        return validateAssistantResult(legacyPayload);
+    }
+    const body = safeTrim(enveloped.visibleBody);
+    if (!body) {
+        throw new Error("Chat adapter returned no assistant text");
+    }
+    return {
+        kind: "message",
+        body,
+        structuredPayload: null,
+    };
+}
+function partialBodyFromRawAssistantText(rawText, resultSentinel) {
+    return safeTrim(parseAssistantEnvelope(rawText, resultSentinel).visibleBody) ?? "";
+}
+async function maybeEmitAssistantState(callback, state) {
+    if (!callback)
+        return;
+    await callback(state);
+}
+async function maybeEmitAssistantDelta(callback, delta) {
+    if (!callback || !delta)
+        return;
+    await callback(delta);
+}
+async function maybeEmitTranscriptEntry(callback, entry) {
+    if (!callback)
+        return;
+    await callback(entry);
+}
+async function maybeEmitObservedTranscriptEntry(callback, entry) {
+    if (!callback)
+        return;
+    await callback(entry);
+}
+function shouldSuppressChatTranscriptEntry(entry, resultSentinel) {
+    if (entry.kind === "result") {
+        return true;
+    }
+    if (entry.kind === "stdout" && entry.text.includes(resultSentinel)) {
+        return true;
+    }
+    return false;
+}
+export function chatAssistantService(db) {
+    const agentsSvc = agentService(db);
+    const organizationsSvc = organizationService(db);
+    const runContextSvc = agentRunContextService(db);
+    async function resolveChatInvocation(input) {
+        const runtimeSource = await resolveConversationRuntime(input.conversation);
+        if (!runtimeSource.descriptor.available) {
+            return {
+                runtimeSource,
+                adapter: null,
+                config: null,
+                linkedIssueIds: [],
+                linkedProjectId: null,
+                resolvedWorkspace: null,
+                sceneContext: null,
+                availabilityError: runtimeSource.descriptor.error ?? "Chat assistant is not configured",
+            };
+        }
+        if (!runtimeSource.agentRuntimeType || !runtimeSource.agentRuntimeConfig || !runtimeSource.runtimeAgent) {
+            return {
+                runtimeSource,
+                adapter: null,
+                config: null,
+                linkedIssueIds: [],
+                linkedProjectId: null,
+                resolvedWorkspace: null,
+                sceneContext: null,
+                availabilityError: runtimeSource.descriptor.error ?? "Chat runtime is not configured",
+            };
+        }
+        const adapter = findServerAdapter(runtimeSource.agentRuntimeType);
+        if (!adapter) {
+            return {
+                runtimeSource,
+                adapter: null,
+                config: null,
+                linkedIssueIds: [],
+                linkedProjectId: null,
+                resolvedWorkspace: null,
+                sceneContext: null,
+                availabilityError: `Unknown chat adapter type: ${runtimeSource.agentRuntimeType}`,
+            };
+        }
+        const config = chatExecutionConfig(input.conversation, runtimeSource.agentRuntimeType, runtimeSource.agentRuntimeConfig);
+        const linkedIssueIds = linkedIssueIdsForChat(input.conversation, input.contextLinks);
+        const linkedProjectId = linkedProjectIdForChat(input.contextLinks);
+        const resolvedWorkspace = await runContextSvc.resolveWorkspaceForRun(runtimeSource.runtimeAgent, {
+            issueId: input.conversation.primaryIssueId ?? linkedIssueIds[0] ?? null,
+            projectId: linkedProjectId,
+        }, null);
+        const sceneContext = await runContextSvc.buildSceneContext({
+            scene: "chat",
+            agent: runtimeSource.runtimeAgent,
+            resolvedWorkspace,
+            runtimeConfig: config,
+        });
+        return {
+            runtimeSource,
+            adapter,
+            config,
+            linkedIssueIds,
+            linkedProjectId,
+            resolvedWorkspace,
+            sceneContext,
+            availabilityError: null,
+        };
+    }
+    async function resolveAgentRuntime(orgId, agentId) {
+        const agent = await agentsSvc.getById(agentId);
+        if (!agent || agent.orgId !== orgId || agent.status === "terminated") {
+            return {
+                descriptor: unavailableAgentDescriptor({
+                    sourceLabel: "Selected agent",
+                    runtimeAgentId: null,
+                    agentRuntimeType: null,
+                    model: null,
+                    error: "The selected chat agent is unavailable. Choose another agent or switch back to Rudder Copilot.",
+                }),
+                runtimeAgent: null,
+                agentRuntimeType: null,
+                agentRuntimeConfig: null,
+                runtimeSkills: [],
+            };
+        }
+        const agentAdapterType = agent.agentRuntimeType;
+        const agentAdapterConfig = (agent.agentRuntimeConfig ?? {});
+        if (CHAT_UNSUPPORTED_ADAPTER_TYPES.has(agentAdapterType)) {
+            return {
+                descriptor: unavailableAgentDescriptor({
+                    sourceLabel: agent.name,
+                    runtimeAgentId: agent.id,
+                    agentRuntimeType: agentAdapterType,
+                    model: modelLabel(agentAdapterConfig) ?? null,
+                    error: `${agent.name} uses ${agentAdapterType}, which does not support chat conversations.`,
+                }),
+                runtimeAgent: {
+                    id: agent.id,
+                    orgId: agent.orgId,
+                    name: agent.name,
+                    agentRuntimeType: agentAdapterType,
+                    agentRuntimeConfig: agentAdapterConfig,
+                },
+                agentRuntimeType: agentAdapterType,
+                agentRuntimeConfig: null,
+                runtimeSkills: [],
+            };
+        }
+        const { runtimeConfig, runtimeSkillEntries } = await runContextSvc.prepareRuntimeConfig({
+            scene: "chat",
+            agent: {
+                id: agent.id,
+                orgId: agent.orgId,
+                name: agent.name,
+                status: agent.status,
+                agentRuntimeType: agentAdapterType,
+                agentRuntimeConfig: agentAdapterConfig,
+                metadata: agent.metadata ?? null,
+            },
+        });
+        return {
+            descriptor: {
+                sourceType: "agent",
+                sourceLabel: agent.name,
+                runtimeAgentId: agent.id,
+                agentRuntimeType: agentAdapterType,
+                model: modelLabel(runtimeConfig) ?? "Default model",
+                available: true,
+                error: null,
+            },
+            runtimeAgent: {
+                id: agent.id,
+                orgId: agent.orgId,
+                name: agent.name,
+                agentRuntimeType: agentAdapterType,
+                agentRuntimeConfig: runtimeConfig,
+            },
+            agentRuntimeType: agentAdapterType,
+            agentRuntimeConfig: runtimeConfig,
+            runtimeSkills: summarizeRuntimeSkills(runtimeSkillEntries),
+        };
+    }
+    async function resolveOrganizationDefaultRuntime(orgId) {
+        const organization = await organizationsSvc.getById(orgId);
+        if (!organization?.defaultChatAgentRuntimeType) {
+            return {
+                descriptor: unconfiguredDescriptor("Chat is not configured. Configure Rudder Copilot in Organization Settings, or assign an agent to this conversation."),
+                runtimeAgent: null,
+                agentRuntimeType: null,
+                agentRuntimeConfig: null,
+                runtimeSkills: [],
+            };
+        }
+        const organizationAdapterType = organization.defaultChatAgentRuntimeType;
+        if (!ORGANIZATION_DEFAULT_CHAT_ADAPTER_TYPES.has(organizationAdapterType)) {
+            return {
+                descriptor: unconfiguredDescriptor(`${organizationAdapterType} is not available as a Rudder Copilot runtime.`),
+                runtimeAgent: null,
+                agentRuntimeType: null,
+                agentRuntimeConfig: null,
+                runtimeSkills: [],
+            };
+        }
+        const copilot = await runContextSvc.ensureChatCopilotAgent({
+            id: organization.id,
+            defaultChatAgentRuntimeType: organization.defaultChatAgentRuntimeType,
+            defaultChatAgentRuntimeConfig: (organization.defaultChatAgentRuntimeConfig ?? {}),
+        });
+        if (!copilot) {
+            return {
+                descriptor: unconfiguredDescriptor("Chat is not configured. Configure Rudder Copilot in Organization Settings, or assign an agent to this conversation."),
+                runtimeAgent: null,
+                agentRuntimeType: null,
+                agentRuntimeConfig: null,
+                runtimeSkills: [],
+            };
+        }
+        const { runtimeConfig, runtimeSkillEntries } = await runContextSvc.prepareRuntimeConfig({
+            scene: "chat",
+            agent: {
+                id: copilot.id,
+                orgId: copilot.orgId,
+                name: RUDDER_COPILOT_LABEL,
+                status: copilot.status,
+                agentRuntimeType: copilot.agentRuntimeType,
+                agentRuntimeConfig: copilot.agentRuntimeConfig ?? {},
+                metadata: copilot.metadata ?? null,
+            },
+        });
+        return {
+            descriptor: {
+                sourceType: "copilot",
+                sourceLabel: RUDDER_COPILOT_LABEL,
+                runtimeAgentId: copilot.id,
+                agentRuntimeType: organizationAdapterType,
+                model: modelLabel(runtimeConfig) ?? "Default model",
+                available: true,
+                error: null,
+            },
+            runtimeAgent: {
+                id: copilot.id,
+                orgId: copilot.orgId,
+                name: RUDDER_COPILOT_LABEL,
+                agentRuntimeType: organizationAdapterType,
+                agentRuntimeConfig: runtimeConfig,
+            },
+            agentRuntimeType: organizationAdapterType,
+            agentRuntimeConfig: runtimeConfig,
+            runtimeSkills: summarizeRuntimeSkills(runtimeSkillEntries),
+        };
+    }
+    async function resolveConversationRuntime(conversation) {
+        if (conversation.preferredAgentId) {
+            const agentRuntime = await resolveAgentRuntime(conversation.orgId, conversation.preferredAgentId);
+            if (agentRuntime)
+                return agentRuntime;
+        }
+        return resolveOrganizationDefaultRuntime(conversation.orgId);
+    }
+    async function enrichConversation(conversation) {
+        const resolved = await resolveConversationRuntime(conversation);
+        return {
+            ...conversation,
+            chatRuntime: resolved.descriptor,
+        };
+    }
+    async function enrichConversations(conversations) {
+        return Promise.all(conversations.map((conversation) => enrichConversation(conversation)));
+    }
+    async function streamChatAssistantReply(input) {
+        const resolvedInvocation = await resolveChatInvocation({
+            conversation: input.conversation,
+            contextLinks: input.contextLinks,
+        });
+        if (resolvedInvocation.availabilityError) {
+            throw new Error(resolvedInvocation.availabilityError);
+        }
+        const { runtimeSource, adapter, config, linkedIssueIds, linkedProjectId, sceneContext, } = resolvedInvocation;
+        if (!adapter || !config || !sceneContext || !runtimeSource.agentRuntimeType) {
+            throw new Error("Chat runtime is not configured");
+        }
+        const runtimeAgentType = runtimeSource.agentRuntimeType;
+        const resultSentinel = `${CHAT_RESULT_SENTINEL_PREFIX}${randomUUID()}__`;
+        const runId = `chat-${input.conversation.id}-${randomUUID()}`;
+        const assistantTextAccumulator = createAssistantTextAccumulator();
+        const sentinelStream = createSentinelStream(resultSentinel);
+        const parser = adapter.parseStdoutLine;
+        let stdoutLineBuffer = "";
+        const { rudderWorkspace, rudderWorkspaces, rudderRuntimeServiceIntents, rudderScene } = sceneContext;
+        const prompt = buildConversationPrompt(input, runtimeSource, resultSentinel, typeof rudderWorkspace.orgResourcesPrompt === "string" ? rudderWorkspace.orgResourcesPrompt : "");
+        const processTranscriptEntries = async (entries) => {
+            for (const entry of entries) {
+                if (entry.kind === "assistant") {
+                    const delta = assistantTextAccumulator.push(entry.text, entry.delta === true);
+                    if (!delta)
+                        continue;
+                    const visibleDelta = sentinelStream.push(delta);
+                    if (visibleDelta) {
+                        await maybeEmitObservedTranscriptEntry(input.onObservedTranscriptEntry, {
+                            kind: "assistant",
+                            ts: entry.ts,
+                            text: visibleDelta,
+                            delta: true,
+                        });
+                    }
+                    await maybeEmitAssistantDelta(input.onAssistantDelta, visibleDelta);
+                    continue;
+                }
+                if (entry.kind === "result") {
+                    await maybeEmitObservedTranscriptEntry(input.onObservedTranscriptEntry, {
+                        ...entry,
+                        text: partialBodyFromRawAssistantText(entry.text, resultSentinel),
+                    });
+                }
+                else if (!(entry.kind === "stdout" && entry.text.includes(resultSentinel))) {
+                    await maybeEmitObservedTranscriptEntry(input.onObservedTranscriptEntry, entry);
+                }
+                if (shouldSuppressChatTranscriptEntry(entry, resultSentinel)) {
+                    continue;
+                }
+                await maybeEmitTranscriptEntry(input.onTranscriptEntry, entry);
+            }
+        };
+        const processStdoutLine = async (line) => {
+            if (!parser || !line.trim())
+                return;
+            await processTranscriptEntries(parser(line, new Date().toISOString()));
+        };
+        const flushStdoutChunk = async (chunk, finalize = false) => {
+            const combined = `${stdoutLineBuffer}${chunk}`;
+            const lines = combined.split(/\r?\n/);
+            stdoutLineBuffer = lines.pop() ?? "";
+            for (const line of lines) {
+                await processStdoutLine(line);
+            }
+            if (finalize && stdoutLineBuffer.trim()) {
+                const trailing = stdoutLineBuffer;
+                stdoutLineBuffer = "";
+                await processStdoutLine(trailing);
+            }
+        };
+        await maybeEmitAssistantState(input.onAssistantState, "streaming");
+        const result = await adapter.execute({
+            runId,
+            agent: stubAgent({
+                orgId: input.conversation.orgId,
+                agentRuntimeType: runtimeAgentType,
+                agentRuntimeConfig: config,
+                sourceLabel: runtimeSource.descriptor.sourceLabel,
+                sourceId: runtimeSource.descriptor.runtimeAgentId ?? `org-chat:${input.conversation.orgId}`,
+            }),
+            runtime: {
+                sessionId: null,
+                sessionParams: null,
+                sessionDisplayId: null,
+                taskKey: null,
+            },
+            config,
+            context: {
+                chatPrompt: prompt,
+                chatConversationId: input.conversation.id,
+                chatMode: true,
+                rudderScene,
+                rudderWorkspace,
+                rudderWorkspaces,
+                ...(rudderRuntimeServiceIntents ? { rudderRuntimeServiceIntents } : {}),
+                ...(linkedProjectId ? { projectId: linkedProjectId } : {}),
+                ...(linkedIssueIds[0] ? { issueId: linkedIssueIds[0] } : {}),
+                ...(linkedIssueIds.length > 0 ? { issueIds: linkedIssueIds } : {}),
+            },
+            onMeta: async (meta) => {
+                await input.onInvocationMeta?.({
+                    ...meta,
+                    loadedSkills: runtimeSource.runtimeSkills,
+                });
+            },
+            abortSignal: input.abortSignal,
+            onLog: async (stream, chunk) => {
+                if (stream === "stdout") {
+                    await flushStdoutChunk(chunk);
+                }
+            },
+        });
+        await flushStdoutChunk("", true);
+        await maybeEmitAssistantDelta(input.onAssistantDelta, sentinelStream.finish());
+        const partialBody = partialBodyFromRawAssistantText(assistantTextAccumulator.fullText || resultText(result), resultSentinel) ||
+            (safeTrim(sentinelStream.visibleText) ?? "");
+        if (input.abortSignal?.aborted) {
+            await maybeEmitAssistantState(input.onAssistantState, "stopped");
+            return {
+                outcome: "stopped",
+                partialBody,
+                replyingAgentId: runtimeSource.descriptor.runtimeAgentId,
+            };
+        }
+        if (result.timedOut) {
+            throw new ChatAssistantStreamError("Chat request timed out", partialBody);
+        }
+        if ((result.exitCode ?? 0) !== 0 || result.errorMessage) {
+            throw new ChatAssistantStreamError(result.errorMessage ?? "Chat adapter execution failed", partialBody);
+        }
+        await maybeEmitAssistantState(input.onAssistantState, "finalizing");
+        const raw = resultText(result) || assistantTextAccumulator.fullText;
+        const reply = parseCompletedAssistantReply(raw, resultSentinel);
+        const finalBody = reply.body;
+        reply.replyingAgentId = runtimeSource.descriptor.runtimeAgentId;
+        const streamedBody = safeTrim(sentinelStream.visibleText) ?? "";
+        if (finalBody.startsWith(streamedBody)) {
+            const delta = finalBody.slice(streamedBody.length);
+            await maybeEmitAssistantDelta(input.onAssistantDelta, delta);
+        }
+        else if (!streamedBody && finalBody) {
+            await maybeEmitAssistantDelta(input.onAssistantDelta, finalBody);
+        }
+        return {
+            outcome: "completed",
+            reply,
+            partialBody: finalBody,
+            replyingAgentId: runtimeSource.descriptor.runtimeAgentId,
+        };
+    }
+    return {
+        enrichConversation,
+        enrichConversations,
+        getChatAssistantAvailability: async (conversation) => {
+            const resolved = await resolveChatInvocation({
+                conversation,
+                contextLinks: Array.isArray(conversation.contextLinks) ? conversation.contextLinks : [],
+            });
+            return resolved.runtimeSource.descriptor.available && !resolved.availabilityError
+                ? {
+                    ...resolved.runtimeSource.descriptor,
+                    available: true,
+                }
+                : {
+                    ...resolved.runtimeSource.descriptor,
+                    available: false,
+                    error: resolved.availabilityError ?? resolved.runtimeSource.descriptor.error,
+                };
+        },
+        generateChatAssistantReply: async (input) => {
+            const result = await streamChatAssistantReply(input);
+            if (result.outcome !== "completed") {
+                throw new Error("Chat assistant reply was stopped before completion");
+            }
+            return result.reply;
+        },
+        streamChatAssistantReply,
+    };
+}
+//# sourceMappingURL=chat-assistant.js.map