@elizaos/agent 0.25.9 → 2.0.0-alpha.144

package/apps/app-training/src/core/cli.js

@@ -0,0 +1,302 @@
+/**
+ * CLI entry point for the training data pipeline.
+ *
+ * Usage:
+ *   bun run packages/agent/src/training/cli.ts generate --variants 5 --output ./training-data
+ *   bun run packages/agent/src/training/cli.ts validate --input ./training-data/raw_samples.json
+ *   bun run packages/agent/src/training/cli.ts export-trajectories --output ./training-data/trajectories.jsonl
+ *   bun run packages/agent/src/training/cli.ts tune --project my-gcp-project --bucket my-bucket --model flash-lite --data ./training-data/should_respond_training.jsonl
+ */
+import { readFile } from "fs/promises";
+import { parseArgs } from "util";
+import { createAnthropicTeacher, createOpenAITeacher, exportToGeminiJSONL, generateDataset, } from "./dataset-generator.js";
+import { formatQualityReport, validateDataset } from "./replay-validator.js";
+import { buildRoleplayEpisodes, exportRoleplayEpisodes, } from "./roleplay-trajectories.js";
+import { ALL_BLUEPRINTS, BLUEPRINT_STATS } from "./scenario-blueprints.js";
+import { createTuningJob, listTuningJobs, normalizeVertexBaseModel, orchestrateVertexTuning, waitForTuningJob, } from "./vertex-tuning.js";
+function getTeacherModel() {
+    const anthropicKey = process.env.ANTHROPIC_API_KEY;
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (anthropicKey) {
+        console.log("Using Anthropic Claude Sonnet 4 as teacher model");
+        return createAnthropicTeacher(anthropicKey);
+    }
+    if (openaiKey) {
+        console.log("Using OpenAI GPT-5 as teacher model");
+        return createOpenAITeacher(openaiKey);
+    }
+    throw new Error("No teacher model API key found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY.");
+}
+async function cmdGenerate(args) {
+    const { values } = parseArgs({
+        args,
+        options: {
+            variants: { type: "string", default: "5" },
+            output: { type: "string", default: "./training-data" },
+            concurrency: { type: "string", default: "5" },
+            contexts: { type: "string" },
+            decisions: { type: "string" },
+            limitBlueprints: { type: "string" },
+        },
+    });
+    const variantsPerBlueprint = parseInt(values.variants, 10);
+    const outputDir = values.output;
+    const concurrency = parseInt(values.concurrency, 10);
+    const filterContexts = values.contexts
+        ? values.contexts.split(",")
+        : undefined;
+    const filterDecisions = values.decisions
+        ? values.decisions.split(",")
+        : undefined;
+    const limitBlueprints = values.limitBlueprints
+        ? parseInt(values.limitBlueprints, 10)
+        : undefined;
+    const teacher = getTeacherModel();
+    const blueprintCount = limitBlueprints
+        ? Math.min(limitBlueprints, ALL_BLUEPRINTS.length)
+        : ALL_BLUEPRINTS.length;
+    console.log(`\nScenario blueprints: ${ALL_BLUEPRINTS.length}`);
+    console.log(`Manual blueprints: ${BLUEPRINT_STATS.manualCount}`);
+    console.log(`Generated blueprints: ${BLUEPRINT_STATS.totalCount - BLUEPRINT_STATS.manualCount}`);
+    console.log(`Variants per blueprint: ${variantsPerBlueprint}`);
+    console.log(`Expected total samples: ${blueprintCount * variantsPerBlueprint}`);
+    console.log(`Output directory: ${outputDir}`);
+    console.log(`Teacher model: ${teacher.name}`);
+    console.log(`Concurrency: ${concurrency}`);
+    if (filterContexts)
+        console.log(`Filter contexts: ${filterContexts.join(", ")}`);
+    if (filterDecisions)
+        console.log(`Filter decisions: ${filterDecisions.join(", ")}`);
+    if (limitBlueprints)
+        console.log(`Limit blueprints: ${limitBlueprints}`);
+    console.log("");
+    const config = {
+        variantsPerBlueprint,
+        teacher,
+        outputDir,
+        concurrency,
+        filterContexts,
+        filterDecisions,
+        limitBlueprints,
+        onProgress: (completed, total, sample) => {
+            const pct = ((completed / total) * 100).toFixed(1);
+            process.stdout.write(`\r[${pct}%] ${completed}/${total} - ${sample.blueprintId} (${sample.expectedOutput.decision}/${sample.expectedOutput.primaryContext})`);
+        },
+    };
+    console.log("Generating synthetic training data...\n");
+    const samples = await generateDataset(config);
+    console.log(`\n\nGenerated ${samples.length} samples.`);
+    // Validate
+    console.log("\nValidating dataset...");
+    const report = validateDataset(samples);
+    console.log(formatQualityReport(report));
+    // Export
+    console.log("\nExporting to Gemini JSONL format...");
+    const paths = await exportToGeminiJSONL(samples, outputDir);
+    console.log(`  Combined: ${paths.combinedPath}`);
+    console.log(`  Should-respond only: ${paths.shouldRespondPath}`);
+    console.log(`  Context routing: ${paths.contextRoutingPath}`);
+    const roleplayPaths = await exportRoleplayEpisodes(buildRoleplayEpisodes(samples), samples, outputDir);
+    console.log(`  Roleplay episodes: ${roleplayPaths.episodesPath}`);
+    console.log(`  Roleplay manifest: ${roleplayPaths.manifestPath}`);
+    console.log("\nDone!");
+}
+async function cmdValidate(args) {
+    const { values } = parseArgs({
+        args,
+        options: {
+            input: { type: "string", short: "i" },
+        },
+    });
+    if (!values.input) {
+        console.error("Usage: validate --input <path-to-raw_samples.json>");
+        process.exit(1);
+    }
+    const raw = await readFile(values.input, "utf-8");
+    const samples = JSON.parse(raw);
+    console.log(`Loaded ${samples.length} samples from ${values.input}`);
+    console.log("");
+    const report = validateDataset(samples);
+    console.log(formatQualityReport(report));
+}
+async function cmdTune(args) {
+    const { values } = parseArgs({
+        args,
+        options: {
+            project: { type: "string" },
+            bucket: { type: "string" },
+            model: { type: "string", default: "gemini-2.5-flash-lite" },
+            data: { type: "string" },
+            validation: { type: "string" },
+            name: { type: "string", default: "eliza-should-respond" },
+            epochs: { type: "string", default: "3" },
+            region: { type: "string", default: "us-central1" },
+        },
+    });
+    if (!values.project || !values.bucket || !values.data) {
+        console.error("Usage: tune --project <gcp-project> --bucket <gcs-bucket> --data <path-to-jsonl> [--model flash-lite|flash] [--name <display-name>]");
+        process.exit(1);
+    }
+    const baseModel = normalizeVertexBaseModel(values.model, "should_respond");
+    const config = {
+        projectId: values.project,
+        region: values.region,
+        gcsBucket: values.bucket,
+        baseModel,
+        trainingDataPath: values.data,
+        validationDataPath: values.validation,
+        epochs: parseInt(values.epochs, 10),
+        displayName: values.name,
+    };
+    console.log(`\nCreating tuning job...`);
+    console.log(`  Project: ${config.projectId}`);
+    console.log(`  Region: ${config.region}`);
+    console.log(`  Base model: ${config.baseModel}`);
+    console.log(`  Training data: ${config.trainingDataPath}`);
+    console.log(`  Display name: ${config.displayName}`);
+    console.log("");
+    const job = await createTuningJob(config);
+    console.log(`Job created: ${job.name}`);
+    console.log(`State: ${job.state}`);
+    console.log("\nPolling for completion (this may take hours)...");
+    const final = await waitForTuningJob(job.name, {
+        onPoll: (j) => {
+            console.log(`  [${new Date().toISOString()}] ${j.state}`);
+        },
+    });
+    if (final.state === "JOB_STATE_SUCCEEDED") {
+        console.log(`\nTuning succeeded!`);
+        console.log(`Tuned model endpoint: ${final.tunedModelEndpointName}`);
+    }
+    else {
+        console.log(`\nTuning failed: ${final.error?.message ?? "unknown error"}`);
+        process.exit(1);
+    }
+}
+async function cmdListJobs(args) {
+    const { values } = parseArgs({
+        args,
+        options: {
+            project: { type: "string" },
+            region: { type: "string", default: "us-central1" },
+        },
+    });
+    if (!values.project) {
+        console.error("Usage: list-jobs --project <gcp-project>");
+        process.exit(1);
+    }
+    const jobs = await listTuningJobs(values.project, values.region);
+    console.log(`\nTuning jobs for ${values.project}:\n`);
+    for (const job of jobs) {
+        console.log(`  ${job.name}`);
+        console.log(`    State: ${job.state}`);
+        console.log(`    Display name: ${job.tunedModelDisplayName}`);
+        console.log(`    Created: ${job.createTime}`);
+        if (job.tunedModelEndpointName) {
+            console.log(`    Endpoint: ${job.tunedModelEndpointName}`);
+        }
+        console.log("");
+    }
+}
+async function cmdOrchestrate(args) {
+    const { values } = parseArgs({
+        args,
+        options: {
+            project: { type: "string" },
+            bucket: { type: "string" },
+            data: { type: "string" },
+            slot: { type: "string", default: "should_respond" },
+            scope: { type: "string", default: "global" },
+            ownerId: { type: "string" },
+            model: { type: "string" },
+            name: { type: "string", default: "eliza-tuned-model" },
+            epochs: { type: "string", default: "3" },
+            region: { type: "string", default: "us-central1" },
+        },
+    });
+    if (!values.project || !values.bucket || !values.data) {
+        console.error("Usage: orchestrate --project <gcp-project> --bucket <gcs-bucket> --data <path-to-jsonl> [--slot should_respond|action_planner|response] [--scope global|organization|user]");
+        process.exit(1);
+    }
+    const result = await orchestrateVertexTuning({
+        projectId: values.project,
+        region: values.region,
+        gcsBucket: values.bucket,
+        baseModel: normalizeVertexBaseModel(values.model, values.slot),
+        trainingDataPath: values.data,
+        epochs: parseInt(values.epochs, 10),
+        displayName: values.name,
+        slot: values.slot,
+        scope: values.scope,
+        ownerId: values.ownerId,
+    });
+    console.log(`\nJob created: ${result.job.name}`);
+    console.log(`Recommended model ID: ${result.recommendedModelId}`);
+    console.log("Model preference patch:");
+    console.log(JSON.stringify(result.modelPreferencePatch, null, 2));
+}
+// ==================== Main ====================
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    const restArgs = args.slice(1);
+    switch (command) {
+        case "generate":
+            await cmdGenerate(restArgs);
+            break;
+        case "validate":
+            await cmdValidate(restArgs);
+            break;
+        case "tune":
+            await cmdTune(restArgs);
+            break;
+        case "list-jobs":
+            await cmdListJobs(restArgs);
+            break;
+        case "orchestrate":
+            await cmdOrchestrate(restArgs);
+            break;
+        default:
+            console.log(`Usage: cli.ts <command> [options]
+
+Commands:
+  generate          Generate synthetic training data
+    --variants N    Number of variants per blueprint (default: 5)
+    --output DIR    Output directory (default: ./training-data)
+    --concurrency N API call concurrency (default: 5)
+    --contexts X,Y  Filter to specific contexts
+    --decisions X,Y Filter to RESPOND,IGNORE,STOP
+
+  validate          Validate a generated dataset
+    --input PATH    Path to raw_samples.json
+
+  tune              Start a Vertex AI fine-tuning job
+    --project ID    GCP project ID
+    --bucket NAME   GCS bucket for training data
+    --data PATH     Path to training JSONL
+    --model TYPE    flash-lite or flash (default: flash-lite)
+    --name NAME     Display name (default: eliza-should-respond)
+    --epochs N      Training epochs (default: 3)
+    --region REG    GCP region (default: us-central1)
+
+  list-jobs         List Vertex AI tuning jobs
+    --project ID    GCP project ID
+
+  orchestrate       Submit a tuned-model job and emit the model preference patch
+    --project ID    GCP project ID
+    --bucket NAME   GCS bucket for training data
+    --data PATH     Path to training JSONL
+    --slot NAME     should_respond | action_planner | response | media_description
+    --scope NAME    global | organization | user
+
+Environment:
+  ANTHROPIC_API_KEY   Use Claude as teacher model
+  OPENAI_API_KEY      Use GPT-5 as teacher model
+`);
+            break;
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/apps/app-training/src/core/context-audit.d.ts

@@ -0,0 +1,51 @@
+import type { AgentRuntime, Plugin } from "@elizaos/core";
+import { type ContextResolutionSource } from "./context-catalog.js";
+import type { AgentContext } from "./context-types.js";
+type AuditComponentType = "action" | "provider";
+export interface ContextAuditEntry {
+    pluginName: string;
+    componentType: AuditComponentType;
+    componentName: string;
+    pluginContexts: AgentContext[];
+    effectiveContexts: AgentContext[];
+    source: ContextResolutionSource;
+}
+export interface ContextAuditGap {
+    pluginName: string;
+    componentType: AuditComponentType;
+    componentName: string;
+    fallbackContexts: AgentContext[];
+    message: string;
+}
+export interface ContextAuditCoverageBreakdown {
+    component: number;
+    plugin: number;
+    catalog: number;
+    default: number;
+}
+export interface ContextAuditSummary {
+    pluginCount: number;
+    actionCount: number;
+    providerCount: number;
+    coverageBySource: {
+        actions: ContextAuditCoverageBreakdown;
+        providers: ContextAuditCoverageBreakdown;
+        overall: ContextAuditCoverageBreakdown;
+    };
+    contextUsage: Record<AgentContext, {
+        actions: number;
+        providers: number;
+    }>;
+    gapCount: number;
+}
+export interface ContextAuditReport extends ContextAuditSummary {
+    generatedAt: string;
+    actions: ContextAuditEntry[];
+    providers: ContextAuditEntry[];
+    gaps: ContextAuditGap[];
+}
+export declare function auditPluginContextCoverage(plugins: Plugin[]): ContextAuditReport;
+export declare function auditRuntimeContextCoverage(runtime: Pick<AgentRuntime, "plugins">): ContextAuditReport;
+export declare function hasContextAuditGaps(report: ContextAuditReport): boolean;
+export {};
+//# sourceMappingURL=context-audit.d.ts.map

package/apps/app-training/src/core/context-audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-audit.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-training/src/core/context-audit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAEL,KAAK,uBAAuB,EAG7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAWvD,KAAK,kBAAkB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEhD,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,kBAAkB,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,YAAY,EAAE,CAAC;IAC/B,iBAAiB,EAAE,YAAY,EAAE,CAAC;IAClC,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,kBAAkB,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,6BAA6B;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE;QAChB,OAAO,EAAE,6BAA6B,CAAC;QACvC,SAAS,EAAE,6BAA6B,CAAC;QACzC,OAAO,EAAE,6BAA6B,CAAC;KACxC,CAAC;IACF,YAAY,EAAE,MAAM,CAClB,YAAY,EACZ;QACE,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB,CACF,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,IAAI,EAAE,eAAe,EAAE,CAAC;CACzB;AA8ID,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EAAE,GAChB,kBAAkB,CAmCpB;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,GACrC,kBAAkB,CAIpB;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAEvE"}

package/apps/app-training/src/core/context-audit.js

@@ -0,0 +1,141 @@
+import { ALL_CONTEXTS, resolveActionContextResolution, resolveProviderContextResolution, } from "./context-catalog.js";
+function normalizeContexts(contexts) {
+    if (!Array.isArray(contexts)) {
+        return [];
+    }
+    return contexts.filter((context) => typeof context === "string" && context.trim().length > 0);
+}
+function createCoverageBreakdown() {
+    return {
+        component: 0,
+        plugin: 0,
+        catalog: 0,
+        default: 0,
+    };
+}
+function createContextUsage() {
+    return Object.fromEntries(ALL_CONTEXTS.map((context) => [
+        context,
+        {
+            actions: 0,
+            providers: 0,
+        },
+    ]));
+}
+function countCoverage(breakdown, source) {
+    breakdown[source] += 1;
+}
+function recordContextUsage(usage, componentType, contexts) {
+    for (const context of contexts) {
+        if (!usage[context]) {
+            usage[context] = {
+                actions: 0,
+                providers: 0,
+            };
+        }
+        if (componentType === "action") {
+            usage[context].actions += 1;
+        }
+        else {
+            usage[context].providers += 1;
+        }
+    }
+}
+function buildGapMessage(componentType, componentName) {
+    return `${componentType} ${componentName} resolved only through the default general-context fallback; add explicit contexts or extend the context catalog`;
+}
+function auditPluginEntries(plugins) {
+    const actions = [];
+    const providers = [];
+    const gaps = [];
+    for (const plugin of plugins) {
+        const pluginName = plugin.name ?? "unknown-plugin";
+        const pluginContexts = normalizeContexts(plugin.contexts);
+        for (const action of plugin.actions ?? []) {
+            const resolution = resolveActionContextResolution(action.name, normalizeContexts(action.contexts), pluginContexts);
+            const entry = {
+                pluginName,
+                componentType: "action",
+                componentName: action.name,
+                pluginContexts,
+                effectiveContexts: resolution.contexts,
+                source: resolution.source,
+            };
+            actions.push(entry);
+            if (resolution.source === "default") {
+                gaps.push({
+                    pluginName,
+                    componentType: "action",
+                    componentName: action.name,
+                    fallbackContexts: resolution.contexts,
+                    message: buildGapMessage("action", action.name),
+                });
+            }
+        }
+        for (const provider of plugin.providers ?? []) {
+            const resolution = resolveProviderContextResolution(provider.name, normalizeContexts(provider.contexts), pluginContexts);
+            const entry = {
+                pluginName,
+                componentType: "provider",
+                componentName: provider.name,
+                pluginContexts,
+                effectiveContexts: resolution.contexts,
+                source: resolution.source,
+            };
+            providers.push(entry);
+            if (resolution.source === "default") {
+                gaps.push({
+                    pluginName,
+                    componentType: "provider",
+                    componentName: provider.name,
+                    fallbackContexts: resolution.contexts,
+                    message: buildGapMessage("provider", provider.name),
+                });
+            }
+        }
+    }
+    return {
+        actions,
+        providers,
+        gaps,
+    };
+}
+export function auditPluginContextCoverage(plugins) {
+    const { actions, providers, gaps } = auditPluginEntries(plugins);
+    const actionCoverage = createCoverageBreakdown();
+    const providerCoverage = createCoverageBreakdown();
+    const overallCoverage = createCoverageBreakdown();
+    const contextUsage = createContextUsage();
+    for (const action of actions) {
+        countCoverage(actionCoverage, action.source);
+        countCoverage(overallCoverage, action.source);
+        recordContextUsage(contextUsage, "action", action.effectiveContexts);
+    }
+    for (const provider of providers) {
+        countCoverage(providerCoverage, provider.source);
+        countCoverage(overallCoverage, provider.source);
+        recordContextUsage(contextUsage, "provider", provider.effectiveContexts);
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        pluginCount: plugins.length,
+        actionCount: actions.length,
+        providerCount: providers.length,
+        coverageBySource: {
+            actions: actionCoverage,
+            providers: providerCoverage,
+            overall: overallCoverage,
+        },
+        contextUsage,
+        gapCount: gaps.length,
+        actions,
+        providers,
+        gaps,
+    };
+}
+export function auditRuntimeContextCoverage(runtime) {
+    return auditPluginContextCoverage(Array.isArray(runtime.plugins) ? runtime.plugins : []);
+}
+export function hasContextAuditGaps(report) {
+    return report.gapCount > 0;
+}

package/apps/app-training/src/core/context-catalog.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Canonical context catalog for all known elizaOS actions, providers, and plugins.
+ *
+ * This catalog maps every known action and provider to one or more AgentContext
+ * categories. It is used by:
+ * 1. The shouldRespondAndRouteContext classifier prompt
+ * 2. The synthetic dataset generator (to scope scenarios per context)
+ * 3. The planner (to filter actions/providers by active context)
+ *
+ * When adding a new plugin/action, add its entry here.
+ */
+import { type AgentContext } from "./context-types.js";
+export type ContextResolutionSource = "component" | "plugin" | "catalog" | "default";
+/** Mapping from action name to its contexts. */
+export declare const ACTION_CONTEXT_MAP: Record<string, AgentContext[]>;
+/** Mapping from provider name to its contexts. */
+export declare const PROVIDER_CONTEXT_MAP: Record<string, AgentContext[]>;
+/** All canonical contexts. */
+export declare const ALL_CONTEXTS: AgentContext[];
+export declare function resolveActionContextResolution(actionName: string, actionContexts?: AgentContext[], pluginContexts?: AgentContext[]): {
+    contexts: AgentContext[];
+    source: ContextResolutionSource;
+};
+export declare function resolveProviderContextResolution(providerName: string, providerContexts?: AgentContext[], pluginContexts?: AgentContext[]): {
+    contexts: AgentContext[];
+    source: ContextResolutionSource;
+};
+/**
+ * Resolve the effective contexts for an action.
+ * Priority: action.contexts > plugin.contexts > catalog lookup > ["general"]
+ */
+export declare function resolveActionContexts(actionName: string, actionContexts?: AgentContext[], pluginContexts?: AgentContext[]): AgentContext[];
+/**
+ * Resolve the effective contexts for a provider.
+ */
+export declare function resolveProviderContexts(providerName: string, providerContexts?: AgentContext[], pluginContexts?: AgentContext[]): AgentContext[];
+/**
+ * Given active contexts, return all actions that should be available.
+ */
+export declare function filterActionsByContexts(activeContexts: AgentContext[], allActions: Array<{
+    name: string;
+    contexts?: AgentContext[];
+}>, pluginContexts?: Record<string, AgentContext[]>): Array<{
+    name: string;
+    contexts?: AgentContext[];
+}>;
+//# sourceMappingURL=context-catalog.d.ts.map

package/apps/app-training/src/core/context-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-catalog.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-training/src/core/context-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvE,MAAM,MAAM,uBAAuB,GAC/B,WAAW,GACX,QAAQ,GACR,SAAS,GACT,SAAS,CAAC;AAEd,gDAAgD;AAChD,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAgH7D,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CA+C/D,CAAC;AAEF,8BAA8B;AAC9B,eAAO,MAAM,YAAY,EAAE,YAAY,EAAwB,CAAC;AAoChE,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,YAAY,EAAE,EAC/B,cAAc,CAAC,EAAE,YAAY,EAAE,GAC9B;IACD,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,MAAM,EAAE,uBAAuB,CAAC;CACjC,CA6BA;AAED,wBAAgB,gCAAgC,CAC9C,YAAY,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,YAAY,EAAE,EACjC,cAAc,CAAC,EAAE,YAAY,EAAE,GAC9B;IACD,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,MAAM,EAAE,uBAAuB,CAAC;CACjC,CA6BA;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,YAAY,EAAE,EAC/B,cAAc,CAAC,EAAE,YAAY,EAAE,GAC9B,YAAY,EAAE,CAMhB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,YAAY,EAAE,EACjC,cAAc,CAAC,EAAE,YAAY,EAAE,GAC9B,YAAY,EAAE,CAMhB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,YAAY,EAAE,EAC9B,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,CAAC,EAC9D,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,GAC9C,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,CAAC,CAapD"}