@yagr/agent 0.1.0

package/dist/tools/search-workspace.js

@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readTextFile, relativeWorkspacePath, resolveWorkspacePath, shouldIgnorePath, truncateText, workspaceRoot } from './workspace-utils.js';
+function visitFiles(targetPath, results) {
+    if (shouldIgnorePath(targetPath)) {
+        return;
+    }
+    const stats = fs.statSync(targetPath);
+    if (stats.isFile()) {
+        results.push(targetPath);
+        return;
+    }
+    for (const entry of fs.readdirSync(targetPath, { withFileTypes: true })) {
+        visitFiles(path.join(targetPath, entry.name), results);
+    }
+}
+export function createSearchWorkspaceTool(_observer) {
+    return tool({
+        description: 'Search text across workspace files. Use this to find workflow names, maps, node properties, or n8nac config entries.',
+        parameters: z.object({
+            query: z.string().min(1).describe('Plain-text or regular-expression search query.'),
+            path: z.string().default('.').describe('Workspace-relative root path to search in.'),
+            isRegexp: z.boolean().default(false).describe('Interpret query as a JavaScript regular expression.'),
+            maxResults: z.number().int().min(1).max(200).default(50).describe('Maximum number of matches to return.'),
+        }),
+        execute: async ({ query, path: inputPath, isRegexp, maxResults }) => {
+            const targetPath = resolveWorkspacePath(inputPath);
+            try {
+                fs.statSync(targetPath);
+            }
+            catch (error) {
+                return {
+                    query,
+                    matches: [],
+                    ok: false,
+                    path: inputPath,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+            const files = [];
+            visitFiles(targetPath, files);
+            const matcher = isRegexp ? new RegExp(query, 'i') : null;
+            const matches = [];
+            for (const filePath of files) {
+                if (matches.length >= maxResults) {
+                    break;
+                }
+                if (path.relative(workspaceRoot(), filePath).startsWith('node_modules')) {
+                    continue;
+                }
+                let text;
+                try {
+                    text = readTextFile(filePath);
+                }
+                catch {
+                    continue;
+                }
+                const lines = text.split(/\r?\n/);
+                for (let index = 0; index < lines.length; index += 1) {
+                    const line = lines[index];
+                    const found = matcher ? matcher.test(line) : line.toLowerCase().includes(query.toLowerCase());
+                    if (!found) {
+                        continue;
+                    }
+                    matches.push({
+                        path: relativeWorkspacePath(filePath),
+                        line: index + 1,
+                        text: truncateText(line, 300),
+                    });
+                    if (matches.length >= maxResults) {
+                        break;
+                    }
+                }
+            }
+            return {
+                ok: true,
+                path: relativeWorkspacePath(targetPath),
+                query,
+                matches,
+            };
+        },
+    });
+}
+//# sourceMappingURL=search-workspace.js.map

package/dist/tools/search-workspace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-workspace.js","sourceRoot":"","sources":["../../src/tools/search-workspace.ts"],"names":[],"mappings":"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"}

package/dist/tools/validate.d.ts

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import type { Engine } from '../engine/engine.js';
+export declare function createValidateWorkflowTool(engine: Engine): import("ai").Tool<z.ZodObject<{
+    workflow: z.ZodObject<{
+        engine: z.ZodEnum<["n8n", "yagr-engine"]>;
+        name: z.ZodString;
+        sourceType: z.ZodEnum<["n8n-json", "yagr-python"]>;
+        definition: z.ZodUnknown;
+        credentialRequirements: z.ZodArray<z.ZodObject<{
+            nodeName: z.ZodString;
+            credentialType: z.ZodString;
+            displayName: z.ZodString;
+            required: z.ZodBoolean;
+            status: z.ZodEnum<["missing", "linked", "unknown"]>;
+            helpUrl: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: "linked" | "missing" | "unknown";
+            credentialType: string;
+            displayName: string;
+            nodeName: string;
+            required: boolean;
+            helpUrl?: string | undefined;
+        }, {
+            status: "linked" | "missing" | "unknown";
+            credentialType: string;
+            displayName: string;
+            nodeName: string;
+            required: boolean;
+            helpUrl?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        engine: "n8n" | "yagr-engine";
+        name: string;
+        sourceType: "n8n-json" | "yagr-python";
+        credentialRequirements: {
+            status: "linked" | "missing" | "unknown";
+            credentialType: string;
+            displayName: string;
+            nodeName: string;
+            required: boolean;
+            helpUrl?: string | undefined;
+        }[];
+        definition?: unknown;
+    }, {
+        engine: "n8n" | "yagr-engine";
+        name: string;
+        sourceType: "n8n-json" | "yagr-python";
+        credentialRequirements: {
+            status: "linked" | "missing" | "unknown";
+            credentialType: string;
+            displayName: string;
+            nodeName: string;
+            required: boolean;
+            helpUrl?: string | undefined;
+        }[];
+        definition?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    workflow: {
+        engine: "n8n" | "yagr-engine";
+        name: string;
+        sourceType: "n8n-json" | "yagr-python";
+        credentialRequirements: {
+            status: "linked" | "missing" | "unknown";
+            credentialType: string;
+            displayName: string;
+            nodeName: string;
+            required: boolean;
+            helpUrl?: string | undefined;
+        }[];
+        definition?: unknown;
+    };
+}, {
+    workflow: {
+        engine: "n8n" | "yagr-engine";
+        name: string;
+        sourceType: "n8n-json" | "yagr-python";
+        credentialRequirements: {
+            status: "linked" | "missing" | "unknown";
+            credentialType: string;
+            displayName: string;
+            nodeName: string;
+            required: boolean;
+            helpUrl?: string | undefined;
+        }[];
+        definition?: unknown;
+    };
+}>, {
+    validation: import("../types.js").WorkflowValidationResult;
+}> & {
+    execute: (args: {
+        workflow: {
+            engine: "n8n" | "yagr-engine";
+            name: string;
+            sourceType: "n8n-json" | "yagr-python";
+            credentialRequirements: {
+                status: "linked" | "missing" | "unknown";
+                credentialType: string;
+                displayName: string;
+                nodeName: string;
+                required: boolean;
+                helpUrl?: string | undefined;
+            }[];
+            definition?: unknown;
+        };
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+        validation: import("../types.js").WorkflowValidationResult;
+    }>;
+};
+//# sourceMappingURL=validate.d.ts.map

package/dist/tools/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/tools/validate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBxD"}

package/dist/tools/validate.js

@@ -0,0 +1,28 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export function createValidateWorkflowTool(engine) {
+    return tool({
+        description: 'Validate a generated workflow before deployment.',
+        parameters: z.object({
+            workflow: z.object({
+                engine: z.enum(['n8n', 'yagr-engine']),
+                name: z.string(),
+                sourceType: z.enum(['n8n-json', 'yagr-python']),
+                definition: z.unknown(),
+                credentialRequirements: z.array(z.object({
+                    nodeName: z.string(),
+                    credentialType: z.string(),
+                    displayName: z.string(),
+                    required: z.boolean(),
+                    status: z.enum(['missing', 'linked', 'unknown']),
+                    helpUrl: z.string().optional(),
+                })),
+            }),
+        }),
+        execute: async ({ workflow }) => {
+            const validation = await engine.validate(workflow);
+            return { validation };
+        },
+    });
+}
+//# sourceMappingURL=validate.js.map

package/dist/tools/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../src/tools/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,MAAM,UAAU,0BAA0B,CAAC,MAAc;IACvD,OAAO,IAAI,CAAC;QACV,WAAW,EAAE,kDAAkD;QAC/D,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC;YACnB,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC;gBACjB,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;gBACtC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;gBAChB,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;gBAC/C,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE;gBACvB,sBAAsB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;oBACvC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;oBACpB,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;oBAC1B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;oBACvB,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;oBACrB,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;oBAChD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;iBAC/B,CAAC,CAAC;aACJ,CAAC;SACH,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;YAC9B,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,QAA6B,CAAC,CAAC;YACxE,OAAO,EAAE,UAAU,EAAE,CAAC;QACxB,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/tools/workspace-utils.d.ts

@@ -0,0 +1,10 @@
+export declare function workspaceRoot(): string;
+export declare function resolveWorkspacePath(targetPath?: string): string;
+export declare function relativeWorkspacePath(targetPath: string): string;
+export declare function truncateText(text: string, maxLength?: number): string;
+export declare function readTextFile(targetPath: string): string;
+export declare function ensureParentDirectory(targetPath: string): void;
+export declare function countOccurrences(haystack: string, needle: string): number;
+export declare function shouldIgnorePath(targetPath: string): boolean;
+export declare function fileExists(targetPath: string): boolean;
+//# sourceMappingURL=workspace-utils.d.ts.map

package/dist/tools/workspace-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-utils.d.ts","sourceRoot":"","sources":["../../src/tools/workspace-utils.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,wBAAgB,oBAAoB,CAAC,UAAU,SAAM,GAAG,MAAM,CAS7D;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,SAAqB,GAAG,MAAM,CAMjF;AAED,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAE9D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAiBzE;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAY5D;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEtD"}

package/dist/tools/workspace-utils.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getYagrHomeDir } from '../config/yagr-home.js';
+const DEFAULT_TEXT_LIMIT = 12_000;
+export function workspaceRoot() {
+    return getYagrHomeDir();
+}
+export function resolveWorkspacePath(targetPath = '.') {
+    const root = workspaceRoot();
+    const resolved = path.resolve(root, targetPath);
+    if (resolved === root || resolved.startsWith(`${root}${path.sep}`)) {
+        return resolved;
+    }
+    throw new Error(`Path must stay inside the active workspace: ${targetPath}`);
+}
+export function relativeWorkspacePath(targetPath) {
+    const relative = path.relative(workspaceRoot(), targetPath);
+    return relative || '.';
+}
+export function truncateText(text, maxLength = DEFAULT_TEXT_LIMIT) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, maxLength)}\n... [truncated ${text.length - maxLength} chars]`;
+}
+export function readTextFile(targetPath) {
+    return fs.readFileSync(targetPath, 'utf-8');
+}
+export function ensureParentDirectory(targetPath) {
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+}
+export function countOccurrences(haystack, needle) {
+    if (!needle) {
+        return 0;
+    }
+    let count = 0;
+    let startIndex = 0;
+    while (true) {
+        const index = haystack.indexOf(needle, startIndex);
+        if (index === -1) {
+            return count;
+        }
+        count += 1;
+        startIndex = index + needle.length;
+    }
+}
+export function shouldIgnorePath(targetPath) {
+    const relative = relativeWorkspacePath(targetPath);
+    return relative === 'node_modules'
+        || relative.startsWith(`node_modules${path.sep}`)
+        || relative === '.git'
+        || relative.startsWith(`.git${path.sep}`)
+        || relative === 'dist'
+        || relative.startsWith(`dist${path.sep}`)
+        || relative === 'build'
+        || relative.startsWith(`build${path.sep}`)
+        || relative === '.next'
+        || relative.startsWith(`.next${path.sep}`);
+}
+export function fileExists(targetPath) {
+    return fs.existsSync(targetPath);
+}
+//# sourceMappingURL=workspace-utils.js.map

package/dist/tools/workspace-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-utils.js","sourceRoot":"","sources":["../../src/tools/workspace-utils.ts"],"names":[],"mappings":"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"}

package/dist/tools/write-workspace-file.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { ToolExecutionObserver } from './observer.js';
+export declare function createWriteWorkspaceFileTool(_observer?: ToolExecutionObserver): import("ai").Tool<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["create", "overwrite", "append"]>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    content: string;
+    mode: "overwrite" | "create" | "append";
+}, {
+    path: string;
+    content: string;
+    mode?: "overwrite" | "create" | "append" | undefined;
+}>, {
+    ok: boolean;
+    path: string;
+    error: string;
+    mode?: undefined;
+    bytesWritten?: undefined;
+} | {
+    ok: boolean;
+    path: string;
+    mode: "overwrite" | "create" | "append";
+    bytesWritten: number;
+    error?: undefined;
+}> & {
+    execute: (args: {
+        path: string;
+        content: string;
+        mode: "overwrite" | "create" | "append";
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+        ok: boolean;
+        path: string;
+        error: string;
+        mode?: undefined;
+        bytesWritten?: undefined;
+    } | {
+        ok: boolean;
+        path: string;
+        mode: "overwrite" | "create" | "append";
+        bytesWritten: number;
+        error?: undefined;
+    }>;
+};
+//# sourceMappingURL=write-workspace-file.d.ts.map

package/dist/tools/write-workspace-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-workspace-file.d.ts","sourceRoot":"","sources":["../../src/tools/write-workspace-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAG3D,wBAAgB,4BAA4B,CAAC,SAAS,CAAC,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC7E"}

package/dist/tools/write-workspace-file.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ensureParentDirectory, fileExists, relativeWorkspacePath, resolveWorkspacePath } from './workspace-utils.js';
+export function createWriteWorkspaceFileTool(_observer) {
+    return tool({
+        description: 'Create or overwrite a workspace file. Use this for new .workflow.ts files or deliberate full-file rewrites.',
+        parameters: z.object({
+            path: z.string().min(1).describe('Workspace-relative file path.'),
+            content: z.string().describe('Full file content to write.'),
+            mode: z.enum(['create', 'overwrite', 'append']).default('overwrite').describe('Write mode for the target file.'),
+        }),
+        execute: async ({ path: inputPath, content, mode }) => {
+            const targetPath = resolveWorkspacePath(inputPath);
+            const exists = fileExists(targetPath);
+            if (mode === 'create' && exists) {
+                return {
+                    ok: false,
+                    path: relativeWorkspacePath(targetPath),
+                    error: `File already exists: ${inputPath}`,
+                };
+            }
+            ensureParentDirectory(targetPath);
+            if (mode === 'append') {
+                fs.appendFileSync(targetPath, content, 'utf-8');
+            }
+            else {
+                fs.writeFileSync(targetPath, content, 'utf-8');
+            }
+            return {
+                ok: true,
+                path: relativeWorkspacePath(targetPath),
+                mode,
+                bytesWritten: Buffer.byteLength(content, 'utf-8'),
+            };
+        },
+    });
+}
+//# sourceMappingURL=write-workspace-file.js.map

package/dist/tools/write-workspace-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-workspace-file.js","sourceRoot":"","sources":["../../src/tools/write-workspace-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEtH,MAAM,UAAU,4BAA4B,CAAC,SAAiC;IAC5E,OAAO,IAAI,CAAC;QACV,WAAW,EAAE,6GAA6G;QAC1H,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC;YACnB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,+BAA+B,CAAC;YACjE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC;YAC3D,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,iCAAiC,CAAC;SACjH,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE;YACpD,MAAM,UAAU,GAAG,oBAAoB,CAAC,SAAS,CAAC,CAAC;YACnD,MAAM,MAAM,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;YAEtC,IAAI,IAAI,KAAK,QAAQ,IAAI,MAAM,EAAE,CAAC;gBAChC,OAAO;oBACL,EAAE,EAAE,KAAK;oBACT,IAAI,EAAE,qBAAqB,CAAC,UAAU,CAAC;oBACvC,KAAK,EAAE,wBAAwB,SAAS,EAAE;iBAC3C,CAAC;YACJ,CAAC;YAED,qBAAqB,CAAC,UAAU,CAAC,CAAC;YAElC,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,EAAE,CAAC,cAAc,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YAClD,CAAC;iBAAM,CAAC;gBACN,EAAE,CAAC,aAAa,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YACjD,CAAC;YAED,OAAO;gBACL,EAAE,EAAE,IAAI;gBACR,IAAI,EAAE,qBAAqB,CAAC,UAAU,CAAC;gBACvC,IAAI;gBACJ,YAAY,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC;aAClD,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,243 @@
+import type { N8nWorkflow } from '@n8n-as-code/transformer';
+import type { ValidationResult as SkillsValidationResult } from '@n8n-as-code/skills';
+import type { YagrLanguageModelConfig, YagrModelProvider } from './llm/create-language-model.js';
+export type EngineName = 'n8n' | 'yagr-engine';
+export interface NodeSummary {
+    name: string;
+    type: string;
+    displayName?: string;
+    description?: string;
+    category?: string;
+}
+export interface TemplateSummary {
+    id: string;
+    title: string;
+    excerpt?: string;
+    category?: string;
+    url?: string;
+}
+export interface WorkflowSpecNode {
+    name: string;
+    type: string;
+    parameters: Record<string, unknown>;
+    typeVersion?: number;
+    position?: [number, number];
+    credentials?: Record<string, {
+        id?: string;
+        name?: string;
+    }>;
+}
+export interface WorkflowSpecConnection {
+    from: string;
+    to: string;
+    type?: string;
+    index?: number;
+}
+export type WorkflowSpecConnections = WorkflowSpecConnection[] | Record<string, Record<string, Array<Array<{
+    node: string;
+    type: string;
+    index?: number;
+}>>>> | Record<string, WorkflowSpecConnection[]>;
+export interface WorkflowSpec {
+    name: string;
+    nodes: WorkflowSpecNode[];
+    connections: WorkflowSpecConnections;
+    active?: boolean;
+}
+export interface CredentialRequirement {
+    nodeName: string;
+    credentialType: string;
+    displayName: string;
+    required: boolean;
+    status: 'missing' | 'linked' | 'unknown';
+    helpUrl?: string;
+}
+export interface GeneratedWorkflow {
+    engine: EngineName;
+    name: string;
+    sourceType: 'n8n-json' | 'yagr-python';
+    definition: N8nWorkflow | string;
+    credentialRequirements: CredentialRequirement[];
+}
+export interface DeployedWorkflow {
+    id: string;
+    engine: EngineName;
+    name: string;
+    active: boolean;
+    workflowUrl?: string;
+    credentialRequirements: CredentialRequirement[];
+}
+export interface WorkflowValidationResult {
+    valid: boolean;
+    errors: SkillsValidationResult['errors'];
+    warnings: SkillsValidationResult['warnings'];
+}
+export interface N8nEngineConfig {
+    host: string;
+    apiKey: string;
+    syncFolder: string;
+    projectId: string;
+    projectName: string;
+    instanceIdentifier?: string;
+}
+export type { YagrLanguageModelConfig, YagrModelProvider };
+export type YagrRunPhase = 'inspect' | 'plan' | 'edit' | 'validate' | 'sync' | 'verify' | 'summarize';
+export type YagrAgentState = 'idle' | 'running' | 'streaming' | 'stopped' | 'waiting_for_permission' | 'waiting_for_input' | 'compacting' | 'resumable' | 'completed' | 'failed_terminal';
+export type YagrRequiredActionKind = 'input' | 'permission' | 'external';
+export interface YagrRequiredAction {
+    id: string;
+    kind: YagrRequiredActionKind;
+    title: string;
+    message: string;
+    detail?: string;
+    resumable: boolean;
+}
+export interface YagrToolCallTrace {
+    toolName: string;
+    args: unknown;
+}
+export interface YagrToolResultTrace {
+    toolName: string;
+    result: unknown;
+}
+export type YagrToolEvent = {
+    type: 'status';
+    toolName: string;
+    message: string;
+} | {
+    type: 'command-start';
+    toolName: string;
+    command: string;
+    cwd?: string;
+    message?: string;
+} | {
+    type: 'command-output';
+    toolName: string;
+    stream: 'stdout' | 'stderr';
+    chunk: string;
+} | {
+    type: 'command-end';
+    toolName: string;
+    exitCode: number;
+    timedOut?: boolean;
+    message?: string;
+} | {
+    type: 'result';
+    toolName: string;
+    message: string;
+};
+export interface YagrRunStep {
+    stepNumber: number;
+    stepType: string;
+    finishReason: string;
+    toolCalls: YagrToolCallTrace[];
+    toolResults: YagrToolResultTrace[];
+    text: string;
+    phase: YagrRunPhase;
+}
+export interface YagrPhaseEvent {
+    phase: YagrRunPhase;
+    status: 'started' | 'completed';
+    message: string;
+}
+export interface YagrStateEvent {
+    state: YagrAgentState;
+    phase?: YagrRunPhase;
+    message: string;
+}
+export interface YagrRuntimeContext {
+    runId: string;
+    phase?: YagrRunPhase;
+    state: YagrAgentState;
+}
+export interface YagrToolHookContext extends YagrRuntimeContext {
+    toolName: string;
+    args: unknown;
+}
+export interface YagrToolHookDecision {
+    allowed?: boolean;
+    message?: string;
+    requiredAction?: YagrRequiredAction;
+}
+export interface YagrCompletionAttempt {
+    text: string;
+    finishReason: string;
+    requiredActions: YagrRequiredAction[];
+}
+export interface YagrCompletionHookDecision {
+    accepted?: boolean;
+    message?: string;
+    requiredAction?: YagrRequiredAction;
+}
+export interface YagrRuntimeHook {
+    beforeTool?: (context: YagrToolHookContext) => void | YagrToolHookDecision | Promise<void | YagrToolHookDecision>;
+    afterTool?: (context: YagrToolHookContext & {
+        result: unknown;
+    }) => void | Promise<void>;
+    beforeCompletion?: (attempt: YagrCompletionAttempt, context: YagrRuntimeContext) => void | YagrCompletionHookDecision | Promise<void | YagrCompletionHookDecision>;
+}
+export interface YagrRunJournalEntry {
+    timestamp: string;
+    type: 'run' | 'phase' | 'step' | 'state' | 'compaction';
+    status: 'started' | 'completed' | 'failed';
+    message: string;
+    phase?: YagrRunPhase;
+    state?: YagrAgentState;
+    requiredAction?: YagrRequiredAction;
+    compaction?: YagrContextCompactionEvent;
+    stepNumber?: number;
+    runId?: string;
+    step?: YagrRunStep;
+}
+export interface YagrContextCompactionEvent {
+    summary: string;
+    source: 'llm' | 'fallback';
+    estimatedTokens: number;
+    thresholdTokens: number;
+    messagesCompacted: number;
+    preservedRecentMessages: number;
+    fallbackReason?: string;
+}
+export interface YagrDisplayOptions {
+    showThinking?: boolean;
+    showExecution?: boolean;
+    showResponses?: boolean;
+    showUserPrompts?: boolean;
+}
+export interface YagrRunOptions extends YagrLanguageModelConfig {
+    abortSignal?: AbortSignal;
+    maxSteps?: number;
+    rememberConversation?: boolean;
+    autoCompactContext?: boolean;
+    compactContextThresholdPercent?: number;
+    compactPreserveRecentMessages?: number;
+    charsPerToken?: number;
+    contextWindowTokens?: number;
+    reservedOutputTokens?: number;
+    satisfiedRequiredActionIds?: string[];
+    display?: YagrDisplayOptions;
+    runtimeHooks?: YagrRuntimeHook[];
+    onCompaction?: (event: YagrContextCompactionEvent) => void | Promise<void>;
+    onTextDelta?: (textDelta: string) => void | Promise<void>;
+    onStepFinish?: (step: YagrRunStep) => void | Promise<void>;
+    onPhaseChange?: (phase: YagrPhaseEvent) => void | Promise<void>;
+    onStateChange?: (state: YagrStateEvent) => void | Promise<void>;
+    onJournalEntry?: (entry: YagrRunJournalEntry) => void | Promise<void>;
+    onToolEvent?: (event: YagrToolEvent) => void | Promise<void>;
+}
+export interface YagrRunResult {
+    runId: string;
+    text: string;
+    finishReason: string;
+    steps: number;
+    toolCalls: Array<{
+        toolName: string;
+    }>;
+    completionAccepted: boolean;
+    requiredActions: YagrRequiredAction[];
+    compactions: YagrContextCompactionEvent[];
+    finalState: YagrAgentState;
+    finalPhase: YagrRunPhase;
+    journal: YagrRunJournalEntry[];
+}
+//# sourceMappingURL=types.d.ts.map