@amplitude/wizard 1.0.0-beta.0

package/dist/src/lib/api.js

@@ -0,0 +1,442 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiProjectSchema = exports.ApiUserSchema = void 0;
+exports.fetchAmplitudeUser = fetchAmplitudeUser;
+exports.fetchBranches = fetchBranches;
+exports.fetchWorkspaceEventTypes = fetchWorkspaceEventTypes;
+exports.fetchOwnedDashboards = fetchOwnedDashboards;
+exports.fetchSources = fetchSources;
+exports.fetchProjectActivationStatus = fetchProjectActivationStatus;
+exports.fetchUserData = fetchUserData;
+exports.fetchProjectData = fetchProjectData;
+const axios_1 = __importDefault(require("axios"));
+const zod_1 = require("zod");
+const analytics_js_1 = require("../utils/analytics.js");
+const constants_js_1 = require("./constants.js");
+// ── Amplitude GraphQL types ───────────────────────────────────────────
+const AmplitudeUserSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        orgs: zod_1.z.array(zod_1.z.object({
+            id: zod_1.z.string(),
+            name: zod_1.z.string(),
+            user: zod_1.z.object({
+                id: zod_1.z.string(),
+                firstName: zod_1.z.string(),
+                lastName: zod_1.z.string(),
+                email: zod_1.z.string(),
+            }),
+            workspaces: zod_1.z.array(zod_1.z.object({
+                id: zod_1.z.string(),
+                name: zod_1.z.string(),
+                environments: zod_1.z
+                    .array(zod_1.z.object({
+                    name: zod_1.z.string(),
+                    rank: zod_1.z.number(),
+                    app: zod_1.z
+                        .object({
+                        id: zod_1.z.string(),
+                        apiKey: zod_1.z.string().nullable().optional(),
+                    })
+                        .nullable(),
+                }))
+                    .nullable()
+                    .optional(),
+            })),
+        })),
+    }),
+});
+const ORGS_QUERY = `
+query orgs {
+  orgs {
+    id
+    name
+    user {
+      id
+      firstName
+      lastName
+      email
+    }
+    workspaces {
+      id
+      name
+      environments {
+        name
+        rank
+        app { id apiKey }
+      }
+    }
+  }
+}`;
+class ApiError extends Error {
+    statusCode;
+    endpoint;
+    constructor(message, statusCode, endpoint) {
+        super(message);
+        this.statusCode = statusCode;
+        this.endpoint = endpoint;
+        this.name = 'ApiError';
+    }
+}
+/**
+ * Fetches the authenticated user's org/workspace info from Amplitude's Data API.
+ * Uses the OAuth id_token as the Authorization header (same as ampli CLI).
+ */
+async function fetchAmplitudeUser(idToken, zone) {
+    const { dataApiUrl } = constants_js_1.AMPLITUDE_ZONE_SETTINGS[zone];
+    try {
+        const response = await axios_1.default.post(dataApiUrl, { query: ORGS_QUERY }, {
+            headers: {
+                Authorization: idToken,
+                'Content-Type': 'application/json',
+                'User-Agent': constants_js_1.WIZARD_USER_AGENT,
+            },
+        });
+        const parsed = AmplitudeUserSchema.parse(response.data);
+        const orgs = parsed.data.orgs;
+        const user = orgs[0]?.user;
+        if (!user)
+            throw new ApiError('No user data returned from Amplitude API');
+        return {
+            id: user.id,
+            firstName: user.firstName,
+            lastName: user.lastName,
+            email: user.email,
+            orgs: orgs.map((org) => ({
+                id: org.id,
+                name: org.name,
+                workspaces: org.workspaces,
+            })),
+        };
+    }
+    catch (error) {
+        const apiError = handleApiError(error, 'fetch Amplitude user data');
+        analytics_js_1.analytics.captureException(apiError, { endpoint: dataApiUrl });
+        throw apiError;
+    }
+}
+// ── Branches ──────────────────────────────────────────────────────────────
+const BranchesSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        orgs: zod_1.z.array(zod_1.z.object({
+            workspaces: zod_1.z.array(zod_1.z.object({
+                branches: zod_1.z.array(zod_1.z.object({
+                    id: zod_1.z.string(),
+                    name: zod_1.z.string(),
+                    default: zod_1.z.boolean(),
+                    currentVersionId: zod_1.z.string(),
+                })),
+            })),
+        })),
+    }),
+});
+const BRANCHES_QUERY = `
+query branches($orgId: ID!, $workspaceId: ID!) {
+  orgs(id: $orgId) {
+    workspaces(id: $workspaceId) {
+      branches {
+        id
+        name
+        default
+        currentVersionId
+      }
+    }
+  }
+}`;
+/** Fetches branches for a workspace. */
+async function fetchBranches(idToken, zone, orgId, workspaceId) {
+    const { dataApiUrl } = constants_js_1.AMPLITUDE_ZONE_SETTINGS[zone];
+    try {
+        const response = await axios_1.default.post(dataApiUrl, { query: BRANCHES_QUERY, variables: { orgId, workspaceId } }, {
+            headers: {
+                Authorization: idToken,
+                'Content-Type': 'application/json',
+                'User-Agent': constants_js_1.WIZARD_USER_AGENT,
+            },
+        });
+        const parsed = BranchesSchema.parse(response.data);
+        return parsed.data.orgs[0]?.workspaces[0]?.branches ?? [];
+    }
+    catch (error) {
+        const apiError = handleApiError(error, 'fetch branches');
+        analytics_js_1.analytics.captureException(apiError, { endpoint: dataApiUrl });
+        throw apiError;
+    }
+}
+// ── Workspace event types ─────────────────────────────────────────────────
+const WorkspaceEventsSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        orgs: zod_1.z.array(zod_1.z.object({
+            workspaces: zod_1.z.array(zod_1.z.object({
+                branches: zod_1.z.array(zod_1.z.object({
+                    versions: zod_1.z.array(zod_1.z.object({
+                        events: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), name: zod_1.z.string() })),
+                    })),
+                })),
+            })),
+        })),
+    }),
+});
+const WORKSPACE_EVENTS_QUERY = `
+query workspaceEvents($orgId: ID!, $workspaceId: ID!, $branchId: ID!, $versionId: ID!) {
+  orgs(id: $orgId) {
+    workspaces(id: $workspaceId) {
+      branches(id: $branchId) {
+        versions(id: $versionId) {
+          events { id name }
+        }
+      }
+    }
+  }
+}`;
+/**
+ * Fetches the event type names cataloged in the default branch of a workspace.
+ * Returns an empty array if the workspace has no events or the query fails.
+ */
+async function fetchWorkspaceEventTypes(idToken, zone, orgId, workspaceId) {
+    const { dataApiUrl } = constants_js_1.AMPLITUDE_ZONE_SETTINGS[zone];
+    try {
+        // Step 1: get default branch + its current version
+        const branches = await fetchBranches(idToken, zone, orgId, workspaceId);
+        const defaultBranch = branches.find((b) => b.default) ?? branches[0];
+        if (!defaultBranch)
+            return [];
+        // Step 2: fetch events for that version
+        const response = await axios_1.default.post(dataApiUrl, {
+            query: WORKSPACE_EVENTS_QUERY,
+            variables: {
+                orgId,
+                workspaceId,
+                branchId: defaultBranch.id,
+                versionId: defaultBranch.currentVersionId,
+            },
+        }, {
+            headers: {
+                Authorization: idToken,
+                'Content-Type': 'application/json',
+                'User-Agent': constants_js_1.WIZARD_USER_AGENT,
+            },
+        });
+        const parsed = WorkspaceEventsSchema.parse(response.data);
+        return (parsed.data.orgs[0]?.workspaces[0]?.branches[0]?.versions[0]?.events.map((e) => e.name) ?? []);
+    }
+    catch {
+        return [];
+    }
+}
+// ── Owned dashboards ──────────────────────────────────────────────────────────
+const OwnedDashboardsSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        ownedDashboards: zod_1.z.array(zod_1.z.object({
+            id: zod_1.z.string(),
+            chartIds: zod_1.z.array(zod_1.z.string()),
+        })),
+    }),
+});
+const OWNED_DASHBOARDS_QUERY = `
+query OwnedDashboards {
+  ownedDashboards {
+    id
+    chartIds
+  }
+}`;
+/**
+ * Checks whether the authenticated user has any charts or dashboards in their org.
+ * Uses the Thunder org-scoped GraphQL endpoint.
+ *
+ * Detection is org-scoped — Thunder has no project-level chart/dashboard listing
+ * API. For a typical new-project user this is equivalent to project-scoped.
+ *
+ * Returns { hasCharts: false, hasDashboards: false } on any error so the
+ * checklist falls back to the default empty state rather than crashing.
+ */
+async function fetchOwnedDashboards(idToken, zone, orgId) {
+    const { appApiUrlBase } = constants_js_1.AMPLITUDE_ZONE_SETTINGS[zone];
+    const url = `${appApiUrlBase}${orgId}`;
+    try {
+        const response = await axios_1.default.post(url, { query: OWNED_DASHBOARDS_QUERY }, {
+            headers: {
+                Authorization: idToken,
+                'Content-Type': 'application/json',
+                'User-Agent': constants_js_1.WIZARD_USER_AGENT,
+            },
+        });
+        const parsed = OwnedDashboardsSchema.parse(response.data);
+        const dashboards = parsed.data.ownedDashboards;
+        return {
+            hasDashboards: dashboards.length > 0,
+            hasCharts: dashboards.some((d) => d.chartIds.length > 0),
+        };
+    }
+    catch {
+        return { hasCharts: false, hasDashboards: false };
+    }
+}
+// ── Sources ───────────────────────────────────────────────────────────────
+const SourcesSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        orgs: zod_1.z.array(zod_1.z.object({
+            workspaces: zod_1.z.array(zod_1.z.object({
+                branches: zod_1.z.array(zod_1.z.object({
+                    versions: zod_1.z.array(zod_1.z.object({
+                        id: zod_1.z.string(),
+                        sources: zod_1.z.array(zod_1.z.object({
+                            id: zod_1.z.string(),
+                            name: zod_1.z.string(),
+                            runtime: zod_1.z
+                                .object({
+                                id: zod_1.z.string(),
+                                platformId: zod_1.z.string(),
+                                platformName: zod_1.z.string(),
+                                languageId: zod_1.z.string(),
+                                languageName: zod_1.z.string(),
+                            })
+                                .nullable(),
+                            destinations: zod_1.z.array(zod_1.z.object({ name: zod_1.z.string(), serviceId: zod_1.z.string() })),
+                        })),
+                    })),
+                })),
+            })),
+        })),
+    }),
+});
+const SOURCES_QUERY = `
+query sources($orgId: ID!, $workspaceId: ID!, $branchId: ID!, $versionId: ID!) {
+  orgs(id: $orgId) {
+    workspaces(id: $workspaceId) {
+      branches(id: $branchId) {
+        versions(id: $versionId) {
+          id
+          sources {
+            id
+            name
+            runtime {
+              id
+              platformId
+              platformName
+              languageId
+              languageName
+            }
+            destinations { name serviceId }
+          }
+        }
+      }
+    }
+  }
+}`;
+/** Fetches sources for a specific branch version. */
+async function fetchSources(idToken, zone, orgId, workspaceId, branchId, versionId) {
+    const { dataApiUrl } = constants_js_1.AMPLITUDE_ZONE_SETTINGS[zone];
+    try {
+        const response = await axios_1.default.post(dataApiUrl, {
+            query: SOURCES_QUERY,
+            variables: { orgId, workspaceId, branchId, versionId },
+        }, {
+            headers: {
+                Authorization: idToken,
+                'Content-Type': 'application/json',
+                'User-Agent': constants_js_1.WIZARD_USER_AGENT,
+            },
+        });
+        const parsed = SourcesSchema.parse(response.data);
+        return (parsed.data.orgs[0]?.workspaces[0]?.branches[0]?.versions[0]?.sources ??
+            []);
+    }
+    catch (error) {
+        const apiError = handleApiError(error, 'fetch sources');
+        analytics_js_1.analytics.captureException(apiError, { endpoint: dataApiUrl });
+        throw apiError;
+    }
+}
+// ── Project activation status ──────────────────────────────────────────────
+const ActivationStatusSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        hasAnyDefaultEventTrackingSourceAndEvents: zod_1.z.object({
+            hasDetSource: zod_1.z.boolean(),
+            hasPageViewedEvent: zod_1.z.boolean(),
+            hasSessionStartEvent: zod_1.z.boolean(),
+            hasSessionEndEvent: zod_1.z.boolean(),
+        }),
+    }),
+});
+const ACTIVATION_STATUS_QUERY = `
+query hasAnyDefaultEventTrackingSourceAndEvents($appId: ID!) {
+  hasAnyDefaultEventTrackingSourceAndEvents(appId: $appId) {
+    hasDetSource
+    hasPageViewedEvent
+    hasSessionStartEvent
+    hasSessionEndEvent
+  }
+}`;
+/**
+ * Checks whether an Amplitude project has ingested any events and whether
+ * the SDK snippet is configured.
+ *
+ * The query lives in Thunder (the main Amplitude app GraphQL server), served
+ * at /graphql/org/:orgId.  orgId is required to construct the endpoint URL.
+ */
+async function fetchProjectActivationStatus(idToken, zone, appId, orgId) {
+    const { appApiUrlBase, dataApiUrl } = constants_js_1.AMPLITUDE_ZONE_SETTINGS[zone];
+    // Use the Thunder org-scoped endpoint when orgId is available; fall back to
+    // the data API (which may not expose this field for all users).
+    const url = orgId ? `${appApiUrlBase}${orgId}` : dataApiUrl;
+    try {
+        const response = await axios_1.default.post(url, { query: ACTIVATION_STATUS_QUERY, variables: { appId: String(appId) } }, {
+            headers: {
+                Authorization: idToken,
+                'Content-Type': 'application/json',
+                'User-Agent': constants_js_1.WIZARD_USER_AGENT,
+            },
+        });
+        const parsed = ActivationStatusSchema.parse(response.data);
+        const s = parsed.data.hasAnyDefaultEventTrackingSourceAndEvents;
+        return {
+            ...s,
+            hasAnyEvents: s.hasPageViewedEvent || s.hasSessionStartEvent || s.hasSessionEndEvent,
+        };
+    }
+    catch (error) {
+        const apiError = handleApiError(error, 'fetch project activation status');
+        analytics_js_1.analytics.captureException(apiError, { endpoint: url });
+        throw apiError;
+    }
+}
+function handleApiError(error, operation) {
+    if (axios_1.default.isAxiosError(error)) {
+        const axiosError = error;
+        const status = axiosError.response?.status;
+        const endpoint = axiosError.config?.url;
+        const gqlMessage = axiosError.response?.data?.errors?.[0]?.message;
+        if (status === 401)
+            return new ApiError(`Authentication failed while trying to ${operation}`, status, endpoint);
+        if (status === 403)
+            return new ApiError(`Access denied while trying to ${operation}`, status, endpoint);
+        const message = gqlMessage ?? `Failed to ${operation}`;
+        return new ApiError(message, status, endpoint);
+    }
+    if (error instanceof zod_1.z.ZodError) {
+        return new ApiError(`Invalid response format while trying to ${operation}`);
+    }
+    return new ApiError(`Unexpected error while trying to ${operation}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+}
+// ── Legacy stubs — kept so files referencing the old Amplitude types compile ──
+exports.ApiUserSchema = zod_1.z.object({ distinct_id: zod_1.z.string() });
+exports.ApiProjectSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    uuid: zod_1.z.string(),
+    organization: zod_1.z.string(),
+    api_token: zod_1.z.string(),
+    name: zod_1.z.string(),
+});
+/** @deprecated Amplitude stub. Use fetchAmplitudeUser instead. */
+// eslint-disable-next-line @typescript-eslint/require-await
+async function fetchUserData(_accessToken, _baseUrl) {
+    throw new Error('fetchUserData is a Amplitude stub — use fetchAmplitudeUser instead');
+}
+/** @deprecated Amplitude stub. Use fetchAmplitudeUser instead. */
+// eslint-disable-next-line @typescript-eslint/require-await
+async function fetchProjectData(_accessToken, _projectId, _baseUrl) {
+    throw new Error('fetchProjectData is a Amplitude stub — use fetchAmplitudeUser instead');
+}

package/dist/src/lib/commandments.d.ts

@@ -0,0 +1 @@
+export declare function getWizardCommandments(): string;

package/dist/src/lib/commandments.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWizardCommandments = getWizardCommandments;
+/**
+ * Wizard-wide commandments that are always appended as a system prompt.
+ *
+ * Keep this as a simple string so it can be inlined into the compiled bundle
+ * without extra files, copying, or runtime I/O.
+ */
+const WIZARD_COMMANDMENTS = [
+    'Never hallucinate an Amplitude API key, host, or any other secret. Always use the real values that have been configured for this project (for example via environment variables).',
+    'Never write API keys, access tokens, or other secrets directly into source code. Always reference environment variables instead, and rely on the wizard-tools MCP server (check_env_keys / set_env_values) to create or update .env files.',
+    'Always use the detect_package_manager tool from the wizard-tools MCP server to determine the package manager. Do not guess based on lockfiles or hard-code npm, yarn, pnpm, bun, pip, etc.',
+    'When installing packages, start the installation as a background task and then continue with other work. Do not block waiting for installs to finish unless explicitly instructed.',
+    'Before writing to any file, you MUST read that exact file immediately beforehand using the Read tool, even if you have already read it earlier in the run. This avoids tool failures and stale edits.',
+    'Treat feature flags, custom properties, and event names as part of an analytics contract. Prefer reusing existing names and patterns in the project. When you must introduce new ones, make them clear, descriptive, and consistent with existing conventions, and avoid scattering the same flag or property across many unrelated callsites.',
+    'Prefer minimal, targeted edits that achieve the requested behavior while preserving existing structure and style. Avoid large refactors, broad reformatting, or unrelated changes unless explicitly requested.',
+    'Do not spawn subagents unless explicitly instructed to do so.',
+    'Use the TodoWrite tool to track your progress. Create a todo list at the start describing the high-level areas of work, mark each as in_progress when you begin it, and completed when done.',
+    'After installing the SDK and adding initialization code, but BEFORE writing any track() calls, you MUST call the confirm_event_plan tool to present the proposed instrumentation plan to the user. Only proceed with instrumentation after the plan is approved. If the user provides feedback, revise the plan accordingly and call confirm_event_plan again. If the plan is skipped, do not instrument any events.',
+].join('\n');
+function getWizardCommandments() {
+    return WIZARD_COMMANDMENTS;
+}

package/dist/src/lib/console-query.d.ts

@@ -0,0 +1,27 @@
+/**
+ * console-query — single-turn Claude call for the ConsoleView.
+ *
+ * Uses the global agent (getAgent) so all calls share the same initialized
+ * SDK config (gateway URL, model, env) rather than making raw fetch calls.
+ */
+import type { WizardSession } from './wizard-session.js';
+export type ConsoleCredentials = {
+    kind: 'gateway';
+    baseUrl: string;
+    apiKey: string;
+} | {
+    kind: 'direct';
+    apiKey: string;
+} | {
+    kind: 'none';
+};
+/** Resolve credentials from session + env, in priority order. */
+export declare function resolveConsoleCredentials(session: WizardSession): ConsoleCredentials;
+/** Build a compact plain-text summary of the current session state for the system prompt. */
+export declare function buildSessionContext(session: WizardSession): string;
+export interface ConversationTurn {
+    role: 'user' | 'assistant';
+    content: string;
+}
+/** Send a message to Claude with optional conversation history and return the text response. */
+export declare function queryConsole(userMessage: string, sessionContext: string, creds: ConsoleCredentials, history?: ConversationTurn[]): Promise<string>;

package/dist/src/lib/console-query.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * console-query — single-turn Claude call for the ConsoleView.
+ *
+ * Uses the global agent (getAgent) so all calls share the same initialized
+ * SDK config (gateway URL, model, env) rather than making raw fetch calls.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConsoleCredentials = resolveConsoleCredentials;
+exports.buildSessionContext = buildSessionContext;
+exports.queryConsole = queryConsole;
+const urls_js_1 = require("../utils/urls.js");
+const wizard_session_js_1 = require("./wizard-session.js");
+const agent_interface_js_1 = require("./agent-interface.js");
+const schemas_js_1 = require("./middleware/schemas.js");
+const wizard_tools_js_1 = require("./wizard-tools.js");
+/** Resolve credentials from session + env, in priority order. */
+function resolveConsoleCredentials(session) {
+    // Gateway: set after initializeAgent runs
+    if (process.env.ANTHROPIC_BASE_URL && process.env.ANTHROPIC_AUTH_TOKEN) {
+        return {
+            kind: 'gateway',
+            baseUrl: process.env.ANTHROPIC_BASE_URL,
+            apiKey: process.env.ANTHROPIC_AUTH_TOKEN,
+        };
+    }
+    // Session credentials: available after auth screen
+    if (session.credentials?.projectApiKey && session.credentials?.host) {
+        const devToken = process.env.WIZARD_PROXY_DEV_TOKEN;
+        return {
+            kind: 'gateway',
+            baseUrl: (0, urls_js_1.getLlmGatewayUrlFromHost)(session.credentials.host),
+            apiKey: devToken ?? session.credentials.projectApiKey,
+        };
+    }
+    // Direct Anthropic API key
+    if (process.env.ANTHROPIC_API_KEY) {
+        return { kind: 'direct', apiKey: process.env.ANTHROPIC_API_KEY };
+    }
+    return { kind: 'none' };
+}
+/** Build a compact plain-text summary of the current session state for the system prompt. */
+function buildSessionContext(session) {
+    const lines = [
+        'You are a helpful assistant embedded in the Amplitude Wizard CLI.',
+        "Answer the user's questions concisely. Focus on the current wizard state below.",
+        '',
+        '--- Current wizard state ---',
+        `Phase: ${session.runPhase ?? wizard_session_js_1.RunPhase.Idle}`,
+    ];
+    if (session.region)
+        lines.push(`Region: ${session.region}`);
+    if (session.detectedFrameworkLabel)
+        lines.push(`Framework: ${session.detectedFrameworkLabel}`);
+    if (session.integration)
+        lines.push(`Integration: ${session.integration}`);
+    if (session.selectedOrgName)
+        lines.push(`Org: ${session.selectedOrgName}`);
+    if (session.selectedWorkspaceName)
+        lines.push(`Workspace: ${session.selectedWorkspaceName}`);
+    if (session.credentials?.projectId)
+        lines.push(`Project ID: ${session.credentials.projectId}`);
+    if (session.runPhase === wizard_session_js_1.RunPhase.Completed) {
+        lines.push('Status: Wizard run completed successfully.');
+    }
+    else if (session.runPhase === wizard_session_js_1.RunPhase.Error) {
+        lines.push('Status: Wizard run finished with an error.');
+    }
+    else if (session.runPhase === wizard_session_js_1.RunPhase.Running) {
+        lines.push('Status: Wizard agent is currently running.');
+    }
+    if (session.outroData?.message) {
+        lines.push(`Last message: ${session.outroData.message}`);
+    }
+    return lines.join('\n');
+}
+/** Send a message to Claude with optional conversation history and return the text response. */
+async function queryConsole(userMessage, sessionContext, creds, history = []) {
+    if (creds.kind === 'none') {
+        return 'Claude is not available yet — complete authentication first.';
+    }
+    const agentConfig = await (0, agent_interface_js_1.getAgent)();
+    const { query } = (await import('@anthropic-ai/claude-agent-sdk'));
+    const historyBlock = history.length > 0
+        ? '\n\n--- Conversation history ---\n' +
+            history
+                .map((t) => `${t.role === 'user' ? 'User' : 'Assistant'}: ${t.content}`)
+                .join('\n') +
+            '\n--- End of history ---'
+        : '';
+    const collectedText = [];
+    const response = query({
+        prompt: userMessage,
+        options: {
+            model: agentConfig.model,
+            cwd: agentConfig.workingDirectory,
+            permissionMode: 'bypassPermissions',
+            mcpServers: agentConfig.mcpServers,
+            allowedTools: wizard_tools_js_1.WIZARD_TOOL_NAMES,
+            systemPrompt: sessionContext + historyBlock,
+            env: process.env,
+        },
+    });
+    for await (const rawMessage of response) {
+        const parsed = (0, schemas_js_1.safeParseSDKMessage)(rawMessage);
+        if (!parsed.ok)
+            continue;
+        const message = parsed.message;
+        if (message.type === 'assistant') {
+            const content = message.message?.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'text' && typeof block.text === 'string') {
+                        collectedText.push(block.text);
+                    }
+                }
+            }
+        }
+    }
+    return collectedText.join('') || '(empty response)';
+}