windmill-components 1.700.2 → 1.700.3

package/package/components/copilot/chat/global/core.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package/components/copilot/chat/global/core.test.js

@@ -0,0 +1,123 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('monaco-editor', () => ({
+    editor: {},
+    languages: {},
+    KeyCode: {},
+    Uri: {
+        parse: (value) => ({ toString: () => value })
+    },
+    MarkerSeverity: {
+        Error: 8,
+        Warning: 4,
+        Info: 2,
+        Hint: 1
+    }
+}));
+vi.mock('@codingame/monaco-vscode-standalone-typescript-language-features', () => ({
+    getTypeScriptWorker: async () => async () => ({}),
+    typescriptVersion: 'test'
+}));
+vi.mock('@codingame/monaco-vscode-languages-service-override', () => ({
+    default: () => ({})
+}));
+vi.mock('$lib/components/vscode', () => ({}));
+vi.mock('$lib/gen', async () => {
+    const actual = await vi.importActual('$lib/gen');
+    function wrapService(target, overrides) {
+        return new Proxy(target, {
+            get(source, property, receiver) {
+                if (typeof property === 'string' && property in overrides) {
+                    return overrides[property];
+                }
+                return Reflect.get(source, property, receiver);
+            }
+        });
+    }
+    return {
+        ...actual,
+        FlowService: wrapService(actual.FlowService, {
+            existsFlowByPath: vi.fn(async () => false)
+        }),
+        VariableService: wrapService(actual.VariableService, {
+            existsVariable: vi.fn(async () => false)
+        })
+    };
+});
+import { globalTools } from './core';
+import { globalDraftStore } from './draftStore.svelte';
+const WORKSPACE = 'global-core-test';
+const toolCallbacks = {
+    setToolStatus: vi.fn(),
+    removeToolStatus: vi.fn()
+};
+function getGlobalTool(name) {
+    const tool = globalTools.find((candidate) => candidate.def.function.name === name);
+    if (!tool) {
+        throw new Error(`Missing global tool "${name}"`);
+    }
+    return tool;
+}
+async function callGlobalTool(name, args) {
+    return getGlobalTool(name).fn({
+        args,
+        workspace: WORKSPACE,
+        helpers: {},
+        toolCallbacks,
+        toolId: `test-${name}`
+    });
+}
+describe('global AI tools', () => {
+    beforeEach(() => {
+        globalDraftStore.clearDrafts(WORKSPACE);
+        vi.clearAllMocks();
+    });
+    it('redacts variable draft values when reading workspace items', async () => {
+        await callGlobalTool('write_variable', {
+            path: 'f/secrets/api_key',
+            value: 'super-secret-token',
+            is_secret: true,
+            description: 'API key'
+        });
+        const raw = await callGlobalTool('read_workspace_item', {
+            type: 'variable',
+            path: 'f/secrets/api_key'
+        });
+        const item = JSON.parse(raw);
+        expect(raw).not.toContain('super-secret-token');
+        expect(item).toEqual({
+            type: 'variable',
+            path: 'f/secrets/api_key',
+            summary: 'API key',
+            isDraft: true
+        });
+    });
+    it('fills an empty rawscript module through set_flow_module_code', async () => {
+        await callGlobalTool('write_flow', {
+            path: 'f/flows/empty-module',
+            summary: 'Flow with empty module',
+            value: JSON.stringify({
+                modules: [
+                    {
+                        id: 'empty_step',
+                        value: {
+                            type: 'rawscript',
+                            language: 'bun',
+                            content: '',
+                            input_transforms: {}
+                        }
+                    }
+                ]
+            })
+        });
+        const code = 'export async function main() {\n\treturn 42\n}';
+        await expect(callGlobalTool('set_flow_module_code', {
+            path: 'f/flows/empty-module',
+            module_id: 'empty_step',
+            code
+        })).resolves.toContain('Updated AI draft flow');
+        await expect(callGlobalTool('read_flow_module_code', {
+            path: 'f/flows/empty-module',
+            module_id: 'empty_step'
+        })).resolves.toBe(code);
+    });
+});

package/package/components/copilot/chat/global/deployRequests.d.ts

@@ -0,0 +1,7 @@
+import type { Flow, NewScript, OpenFlowWPath, Script } from '../../../../gen/types.gen';
+import type { FlowDraftValue, WorkspaceItem } from './draftStore.svelte';
+export type FlowDeployRequestBody = OpenFlowWPath & {
+    deployment_message?: string;
+};
+export declare function buildScriptDeployRequestBody(path: string, draft: WorkspaceItem, existing: Script | undefined, deploymentMessage: string | undefined): NewScript;
+export declare function buildFlowDeployRequestBody(path: string, draftSummary: string | undefined, flowDraft: FlowDraftValue, existing: Flow | undefined, deploymentMessage: string | undefined): FlowDeployRequestBody;

package/package/components/copilot/chat/global/deployRequests.js

@@ -0,0 +1,76 @@
+function preserveOnBehalfOf(email) {
+    return email ? true : undefined;
+}
+export function buildScriptDeployRequestBody(path, draft, existing, deploymentMessage) {
+    if (typeof draft.value !== 'string' || !draft.language) {
+        throw new Error(`Draft script "${path}" is missing content or language.`);
+    }
+    const existingWithMetadata = existing;
+    return {
+        path,
+        summary: draft.summary ?? existing?.summary ?? '',
+        description: existing?.description ?? '',
+        content: draft.value,
+        parent_hash: existing?.hash,
+        schema: existing?.schema,
+        is_template: existing?.is_template,
+        language: draft.language,
+        kind: existing?.kind,
+        tag: existing?.tag,
+        envs: existing?.envs,
+        concurrent_limit: existing?.concurrent_limit,
+        concurrency_time_window_s: existing?.concurrency_time_window_s,
+        debounce_key: existing?.debounce_key,
+        debounce_delay_s: existing?.debounce_delay_s,
+        debounce_args_to_accumulate: existing?.debounce_args_to_accumulate,
+        max_total_debouncing_time: existing?.max_total_debouncing_time,
+        max_total_debounces_amount: existing?.max_total_debounces_amount,
+        cache_ttl: existing?.cache_ttl,
+        cache_ignore_s3_path: existingWithMetadata?.cache_ignore_s3_path,
+        dedicated_worker: existing?.dedicated_worker,
+        ws_error_handler_muted: existing?.ws_error_handler_muted,
+        priority: existing?.priority,
+        restart_unless_cancelled: existing?.restart_unless_cancelled,
+        timeout: existing?.timeout,
+        delete_after_secs: existing?.delete_after_secs,
+        deployment_message: deploymentMessage,
+        concurrency_key: existing?.concurrency_key,
+        visible_to_runner_only: existing?.visible_to_runner_only,
+        auto_kind: existing?.auto_kind,
+        codebase: existing?.codebase,
+        has_preprocessor: existing?.has_preprocessor,
+        on_behalf_of_email: existing?.on_behalf_of_email,
+        preserve_on_behalf_of: preserveOnBehalfOf(existing?.on_behalf_of_email),
+        assets: existingWithMetadata?.assets,
+        modules: existing?.modules,
+        labels: existing?.labels
+    };
+}
+function flowValueWithDraftGroups(flowDraft) {
+    if (flowDraft.groups === undefined) {
+        return flowDraft.value;
+    }
+    return {
+        ...flowDraft.value,
+        groups: flowDraft.groups ?? undefined
+    };
+}
+export function buildFlowDeployRequestBody(path, draftSummary, flowDraft, existing, deploymentMessage) {
+    return {
+        path,
+        summary: draftSummary ?? existing?.summary ?? '',
+        description: existing?.description ?? '',
+        value: flowValueWithDraftGroups(flowDraft),
+        schema: flowDraft.schema ?? existing?.schema ?? {},
+        tag: existing?.tag,
+        ws_error_handler_muted: existing?.ws_error_handler_muted,
+        priority: existing?.priority,
+        dedicated_worker: existing?.dedicated_worker,
+        timeout: existing?.timeout,
+        visible_to_runner_only: existing?.visible_to_runner_only,
+        on_behalf_of_email: existing?.on_behalf_of_email,
+        preserve_on_behalf_of: preserveOnBehalfOf(existing?.on_behalf_of_email),
+        labels: existing?.labels,
+        deployment_message: deploymentMessage
+    };
+}

package/package/components/copilot/chat/global/deployRequests.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package/components/copilot/chat/global/deployRequests.test.js

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import { buildFlowDeployRequestBody, buildScriptDeployRequestBody } from './deployRequests';
+describe('global AI deploy request builders', () => {
+    it('preserves existing script metadata while replacing draft-controlled fields', () => {
+        const existing = {
+            hash: 'parent-hash',
+            path: 'f/demo/script',
+            summary: 'existing summary',
+            description: 'existing description',
+            content: 'old content',
+            schema: { properties: { name: { type: 'string' } } },
+            is_template: true,
+            language: 'bun',
+            kind: 'script',
+            tag: 'node',
+            envs: ['ENV_A'],
+            concurrent_limit: 3,
+            concurrency_time_window_s: 60,
+            concurrency_key: 'key',
+            debounce_key: 'debounce',
+            debounce_delay_s: 5,
+            debounce_args_to_accumulate: ['ids'],
+            max_total_debouncing_time: 120,
+            max_total_debounces_amount: 4,
+            cache_ttl: 30,
+            cache_ignore_s3_path: true,
+            dedicated_worker: true,
+            ws_error_handler_muted: true,
+            priority: 9,
+            restart_unless_cancelled: true,
+            timeout: 300,
+            delete_after_secs: 600,
+            visible_to_runner_only: true,
+            auto_kind: 'script',
+            codebase: 'repo',
+            has_preprocessor: true,
+            on_behalf_of_email: 'deployer@example.com',
+            assets: [{ path: 's3://bucket/key', kind: 's3object' }],
+            modules: { 'helper.ts': { content: 'export const helper = 1', language: 'bun' } },
+            labels: ['prod'],
+            lock: 'stale lock'
+        };
+        const draft = {
+            type: 'script',
+            path: 'f/demo/script',
+            summary: 'draft summary',
+            language: 'bun',
+            value: 'new content',
+            isDraft: true
+        };
+        const requestBody = buildScriptDeployRequestBody('f/demo/script', draft, existing, 'ai deploy');
+        expect(requestBody).toMatchObject({
+            path: 'f/demo/script',
+            parent_hash: 'parent-hash',
+            summary: 'draft summary',
+            description: 'existing description',
+            content: 'new content',
+            schema: existing.schema,
+            tag: 'node',
+            envs: ['ENV_A'],
+            concurrent_limit: 3,
+            concurrency_time_window_s: 60,
+            concurrency_key: 'key',
+            debounce_key: 'debounce',
+            debounce_delay_s: 5,
+            debounce_args_to_accumulate: ['ids'],
+            max_total_debouncing_time: 120,
+            max_total_debounces_amount: 4,
+            cache_ttl: 30,
+            cache_ignore_s3_path: true,
+            dedicated_worker: true,
+            ws_error_handler_muted: true,
+            priority: 9,
+            restart_unless_cancelled: true,
+            timeout: 300,
+            delete_after_secs: 600,
+            visible_to_runner_only: true,
+            auto_kind: 'script',
+            codebase: 'repo',
+            has_preprocessor: true,
+            on_behalf_of_email: 'deployer@example.com',
+            preserve_on_behalf_of: true,
+            assets: existing.assets,
+            modules: existing.modules,
+            labels: ['prod'],
+            deployment_message: 'ai deploy'
+        });
+        expect(requestBody.lock).toBeUndefined();
+    });
+    it('preserves existing flow metadata and uses draft value/schema overrides', () => {
+        const existing = {
+            path: 'f/demo/flow',
+            summary: 'existing summary',
+            description: 'existing description',
+            value: { modules: [] },
+            schema: { required: ['name'] },
+            tag: 'python',
+            ws_error_handler_muted: true,
+            priority: 7,
+            dedicated_worker: true,
+            timeout: 60,
+            visible_to_runner_only: true,
+            on_behalf_of_email: 'deployer@example.com',
+            labels: ['critical']
+        };
+        const draftValue = {
+            value: { modules: [{ id: 'step', value: { type: 'identity' } }] },
+            schema: { properties: { name: { type: 'string' } } },
+            groups: [{ start_id: 'step', end_id: 'step', summary: 'Group' }]
+        };
+        const requestBody = buildFlowDeployRequestBody('f/demo/flow', undefined, draftValue, existing, 'ai deploy');
+        expect(requestBody).toMatchObject({
+            path: 'f/demo/flow',
+            summary: 'existing summary',
+            description: 'existing description',
+            schema: draftValue.schema,
+            tag: 'python',
+            ws_error_handler_muted: true,
+            priority: 7,
+            dedicated_worker: true,
+            timeout: 60,
+            visible_to_runner_only: true,
+            on_behalf_of_email: 'deployer@example.com',
+            preserve_on_behalf_of: true,
+            labels: ['critical'],
+            deployment_message: 'ai deploy'
+        });
+        expect(requestBody.value.modules).toHaveLength(1);
+        expect(requestBody.value.groups).toEqual(draftValue.groups);
+    });
+    it('falls back to existing flow schema when the draft has no schema', () => {
+        const existing = {
+            path: 'f/demo/flow',
+            summary: 'existing summary',
+            value: { modules: [] },
+            schema: { properties: { existing: { type: 'boolean' } } }
+        };
+        const requestBody = buildFlowDeployRequestBody('f/demo/flow', 'draft summary', { value: { modules: [] }, schema: null, groups: null }, existing, undefined);
+        expect(requestBody.summary).toBe('draft summary');
+        expect(requestBody.schema).toBe(existing.schema);
+    });
+});

package/package/components/copilot/chat/global/draftStore.svelte.d.ts

@@ -0,0 +1,55 @@
+import type { AzureTriggerData, CreateResource, CreateVariable, FlowValue, GcpTriggerData, NewHttpTrigger, NewKafkaTrigger, NewMqttTrigger, NewNatsTrigger, NewPostgresTrigger, NewSchedule, NewSqsTrigger, NewWebsocketTrigger, Policy, ScriptLang } from '../../../../gen/types.gen';
+/**
+ * Flow draft value. Mirrors what the backend's create/update flow API expects
+ * — the OpenFlow value, plus the inputs schema and (optional) groups.
+ *
+ * Schema and groups are split out from FlowValue intentionally so that
+ * deploy_workspace_item can preserve them through the draft → workspace
+ * round-trip; an earlier version dropped them on every deploy.
+ */
+export type FlowDraftValue = {
+    value: FlowValue;
+    schema?: Record<string, any> | null;
+    groups?: NonNullable<FlowValue['groups']> | null;
+};
+export declare const TRIGGER_KINDS: readonly ["http", "websocket", "kafka", "nats", "postgres", "mqtt", "sqs", "gcp", "azure"];
+export type TriggerKind = (typeof TRIGGER_KINDS)[number];
+export type TriggerRequestBody = NewHttpTrigger | NewWebsocketTrigger | NewKafkaTrigger | NewNatsTrigger | NewPostgresTrigger | NewMqttTrigger | NewSqsTrigger | GcpTriggerData | AzureTriggerData;
+export type WorkspaceItemType = 'script' | 'flow' | 'schedule' | 'trigger' | 'resource' | 'variable' | 'app';
+export type AppDraftValue = {
+    summary?: string;
+    files: Record<string, string>;
+    runnables: Record<string, any>;
+    data?: any;
+    policy?: Policy;
+    custom_path?: string;
+};
+export type WorkspaceItem = {
+    type: WorkspaceItemType;
+    path: string;
+    summary?: string;
+    language?: ScriptLang;
+    triggerKind?: TriggerKind;
+    value?: string | FlowDraftValue | NewSchedule | TriggerRequestBody | CreateResource | CreateVariable | AppDraftValue;
+    isDraft: boolean;
+};
+export declare function getWorkspaceItemKey(type: WorkspaceItemType, path: string, triggerKind?: TriggerKind): string;
+declare class GlobalDraftStore {
+    private drafts;
+    private getWorkspaceDrafts;
+    private ensureWorkspaceDrafts;
+    listDrafts(workspace: string): WorkspaceItem[];
+    getDraft(workspace: string, type: WorkspaceItemType, path: string, triggerKind?: TriggerKind): WorkspaceItem | undefined;
+    setDraft(workspace: string, item: WorkspaceItem): WorkspaceItem;
+    deleteDraft(workspace: string, type: WorkspaceItemType, path: string, triggerKind?: TriggerKind): void;
+    clearDrafts(workspace: string): void;
+    getScriptDraft(workspace: string, path: string): WorkspaceItem | undefined;
+    getFlowDraft(workspace: string, path: string): WorkspaceItem | undefined;
+    getScheduleDraft(workspace: string, path: string): WorkspaceItem | undefined;
+    getTriggerDraft(workspace: string, kind: TriggerKind, path: string): WorkspaceItem | undefined;
+    getResourceDraft(workspace: string, path: string): WorkspaceItem | undefined;
+    getVariableDraft(workspace: string, path: string): WorkspaceItem | undefined;
+    getAppDraft(workspace: string, path: string): WorkspaceItem | undefined;
+}
+export declare const globalDraftStore: GlobalDraftStore;
+export {};

package/package/components/copilot/chat/global/draftStore.svelte.js

@@ -0,0 +1,78 @@
+export const TRIGGER_KINDS = [
+    'http',
+    'websocket',
+    'kafka',
+    'nats',
+    'postgres',
+    'mqtt',
+    'sqs',
+    'gcp',
+    'azure'
+];
+export function getWorkspaceItemKey(type, path, triggerKind) {
+    if (type === 'trigger') {
+        return `trigger:${triggerKind ?? ''}:${path}`;
+    }
+    return `${type}:${path}`;
+}
+function clone(value) {
+    return structuredClone($state.snapshot(value));
+}
+class GlobalDraftStore {
+    drafts = $state({});
+    getWorkspaceDrafts(workspace) {
+        return this.drafts[workspace] ?? {};
+    }
+    ensureWorkspaceDrafts(workspace) {
+        if (!this.drafts[workspace]) {
+            this.drafts[workspace] = {};
+        }
+        return this.drafts[workspace];
+    }
+    listDrafts(workspace) {
+        return Object.values(this.getWorkspaceDrafts(workspace)).map(clone);
+    }
+    getDraft(workspace, type, path, triggerKind) {
+        const draft = this.getWorkspaceDrafts(workspace)[getWorkspaceItemKey(type, path, triggerKind)];
+        return draft ? clone(draft) : undefined;
+    }
+    setDraft(workspace, item) {
+        const stored = { ...clone(item), isDraft: true };
+        this.ensureWorkspaceDrafts(workspace)[getWorkspaceItemKey(item.type, item.path, item.triggerKind)] = stored;
+        return clone(stored);
+    }
+    deleteDraft(workspace, type, path, triggerKind) {
+        const drafts = this.drafts[workspace];
+        if (!drafts)
+            return;
+        delete drafts[getWorkspaceItemKey(type, path, triggerKind)];
+        if (Object.keys(drafts).length === 0) {
+            delete this.drafts[workspace];
+        }
+    }
+    clearDrafts(workspace) {
+        delete this.drafts[workspace];
+    }
+    getScriptDraft(workspace, path) {
+        return this.getDraft(workspace, 'script', path);
+    }
+    getFlowDraft(workspace, path) {
+        return this.getDraft(workspace, 'flow', path);
+    }
+    getScheduleDraft(workspace, path) {
+        return this.getDraft(workspace, 'schedule', path);
+    }
+    getTriggerDraft(workspace, kind, path) {
+        return this.getDraft(workspace, 'trigger', path, kind);
+    }
+    getResourceDraft(workspace, path) {
+        return this.getDraft(workspace, 'resource', path);
+    }
+    getVariableDraft(workspace, path) {
+        return this.getDraft(workspace, 'variable', path);
+    }
+    getAppDraft(workspace, path) {
+        return this.getDraft(workspace, 'app', path);
+    }
+}
+export const globalDraftStore = new GlobalDraftStore();

package/package/components/copilot/chat/global/draftStore.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package/components/copilot/chat/global/draftStore.test.js

@@ -0,0 +1,44 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { globalDraftStore } from './draftStore.svelte';
+const WORKSPACE_A = 'draft-store-test-a';
+const WORKSPACE_B = 'draft-store-test-b';
+function clearTestDrafts() {
+    globalDraftStore.clearDrafts(WORKSPACE_A);
+    globalDraftStore.clearDrafts(WORKSPACE_B);
+}
+describe('globalDraftStore', () => {
+    beforeEach(clearTestDrafts);
+    it('lists and reads drafts only from the requested workspace', () => {
+        globalDraftStore.setDraft(WORKSPACE_A, {
+            type: 'script',
+            path: 'f/shared/path',
+            language: 'bun',
+            value: 'export async function main() {}',
+            isDraft: true
+        });
+        expect(globalDraftStore.getDraft(WORKSPACE_A, 'script', 'f/shared/path')?.value).toBe('export async function main() {}');
+        expect(globalDraftStore.getDraft(WORKSPACE_B, 'script', 'f/shared/path')).toBeUndefined();
+        expect(globalDraftStore.listDrafts(WORKSPACE_A)).toHaveLength(1);
+        expect(globalDraftStore.listDrafts(WORKSPACE_B)).toHaveLength(0);
+    });
+    it('deletes and clears drafts only from the requested workspace', () => {
+        globalDraftStore.setDraft(WORKSPACE_A, {
+            type: 'flow',
+            path: 'f/shared/path',
+            value: { value: { modules: [] }, schema: null, groups: null },
+            isDraft: true
+        });
+        globalDraftStore.setDraft(WORKSPACE_B, {
+            type: 'flow',
+            path: 'f/shared/path',
+            value: { value: { modules: [] }, schema: { workspace: WORKSPACE_B }, groups: null },
+            isDraft: true
+        });
+        globalDraftStore.deleteDraft(WORKSPACE_A, 'flow', 'f/shared/path');
+        expect(globalDraftStore.getDraft(WORKSPACE_A, 'flow', 'f/shared/path')).toBeUndefined();
+        expect(globalDraftStore.getDraft(WORKSPACE_B, 'flow', 'f/shared/path')).toBeDefined();
+        globalDraftStore.clearDrafts(WORKSPACE_B);
+        expect(globalDraftStore.listDrafts(WORKSPACE_A)).toHaveLength(0);
+        expect(globalDraftStore.listDrafts(WORKSPACE_B)).toHaveLength(0);
+    });
+});

package/package/components/copilot/chat/global/gate.d.ts

@@ -0,0 +1 @@
+export declare function isGlobalAiEnabled(): boolean;

package/package/components/copilot/chat/global/gate.js

@@ -0,0 +1,27 @@
+/**
+ * Dev-only gate for the Global AI chat mode.
+ *
+ * While the mode is being iterated on, it should not be visible to regular
+ * users. Developers/QA enable it in their browser with:
+ *
+ *     localStorage.setItem('wm_dev_global_ai', '1')
+ *
+ * and reload the page. To disable, remove the key or set it to anything else.
+ *
+ * When the mode is ready to ship to everyone, replace every call to
+ * `isGlobalAiEnabled()` with `true` and delete this file. The references are
+ * intentionally narrow (chat mode visibility, custom prompt settings, the
+ * `change_mode` tool enum, and the `/global_drafts` dev route) so the rip-out
+ * is a small grep.
+ */
+const STORAGE_KEY = 'wm_dev_global_ai';
+export function isGlobalAiEnabled() {
+    if (typeof localStorage === 'undefined')
+        return false;
+    try {
+        return localStorage.getItem(STORAGE_KEY) === '1';
+    }
+    catch {
+        return false;
+    }
+}

package/package/components/copilot/chat/shared.d.ts

@@ -25,6 +25,20 @@ export interface ContextStringResult {
     hasDiff: boolean;
     hasFlowModule: boolean;
 }
+/** Count exact occurrences of `search` in `content`. */
+export declare function countExactMatches(content: string, search: string): number;
+/**
+ * Replace exact occurrences of `oldString` with `newString` in `content`.
+ * When `replaceAll` is false, only the first match is replaced. Returns the
+ * original string unchanged when no match is found.
+ */
+export declare function applyExactReplace(content: string, oldString: string, newString: string, replaceAll: boolean): string;
+/**
+ * Match-count-validated exact text replacement. Throws when `oldString` is
+ * missing, and (unless `replaceAll`) when it appears more than once.
+ * `contextLabel` flows into the error message ("not found in the <label>.").
+ */
+export declare function findAndReplace(content: string, oldString: string, newString: string, replaceAll: boolean, contextLabel: string): string;
 export declare const extractAllModules: (modules: FlowModule[]) => FlowModule[];
 export declare function applyCodePiecesToFlowModules(codePieces: FlowModuleCodePieceElement[], flowModules: FlowModule[]): FlowModule[];
 export declare function buildContextString(selectedContext: ContextElement[]): string;
@@ -49,9 +63,9 @@ export type CreatedResourceAction = {
     id: string;
     type: 'open_created_resource';
     label: string;
-    resource: 'schedule' | 'trigger';
+    resource: 'schedule' | 'trigger' | 'resource' | 'variable';
     path: string;
-    targetKind: 'script' | 'flow';
+    targetKind?: 'script' | 'flow';
     triggerKind?: CreatedResourceTriggerKind;
 };
 export type ToolDisplayAction = CreatedResourceAction;

package/package/components/copilot/chat/shared.js

@@ -197,6 +197,46 @@ export const TOOL_PRETTIFY_MAP = {
     add_module: prettifyModuleValue,
     modify_module: prettifyModuleValue
 };
+/** Count exact occurrences of `search` in `content`. */
+export function countExactMatches(content, search) {
+    if (search.length === 0)
+        return 0;
+    let count = 0;
+    let index = 0;
+    while ((index = content.indexOf(search, index)) !== -1) {
+        count++;
+        index += search.length;
+    }
+    return count;
+}
+/**
+ * Replace exact occurrences of `oldString` with `newString` in `content`.
+ * When `replaceAll` is false, only the first match is replaced. Returns the
+ * original string unchanged when no match is found.
+ */
+export function applyExactReplace(content, oldString, newString, replaceAll) {
+    if (replaceAll)
+        return content.split(oldString).join(newString);
+    const index = content.indexOf(oldString);
+    if (index === -1)
+        return content;
+    return content.slice(0, index) + newString + content.slice(index + oldString.length);
+}
+/**
+ * Match-count-validated exact text replacement. Throws when `oldString` is
+ * missing, and (unless `replaceAll`) when it appears more than once.
+ * `contextLabel` flows into the error message ("not found in the <label>.").
+ */
+export function findAndReplace(content, oldString, newString, replaceAll, contextLabel) {
+    const matchCount = countExactMatches(content, oldString);
+    if (matchCount === 0) {
+        throw new Error(`old_string was not found in the ${contextLabel}.`);
+    }
+    if (!replaceAll && matchCount !== 1) {
+        throw new Error(`old_string matched ${matchCount} locations. Make it more specific or set replace_all to true.`);
+    }
+    return applyExactReplace(content, oldString, newString, replaceAll);
+}
 export const extractAllModules = (modules) => {
     return modules.flatMap((m) => {
         if (m.value.type === 'forloopflow' || m.value.type === 'whileloopflow') {