@ixo/oracle-runtime 0.0.1

package/dist/plugins/skills/skills-ucan.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeContext } from '../../plugin-api/types.js';
+/**
+ * Mints an `ixo:skills` UCAN invocation for outbound calls to the skills
+ * registry. The invocation lets ai-skills surface the caller's own published
+ * private skills alongside the public registry rows.
+ *
+ * Returns `undefined` when:
+ *   - the registry's did:web document cannot be resolved (e.g. dev box, no
+ *     network), or
+ *   - the UCAN service cannot mint an invocation (no signing key, no cached
+ *     delegation, etc).
+ *
+ * The skills tools degrade to public-only mode when no token is available —
+ * we never throw, we just skip the authorization header.
+ */
+export type SkillsUcanBuilder = (skillsServiceUrl: string, runCtx: RuntimeContext) => Promise<string | undefined>;
+/**
+ * Default {@link SkillsUcanBuilder}. Uses the same primitives as the sandbox
+ * plugin: `runCtx.ucan.resolveServiceDid` for did:web resolution +
+ * `runCtx.ucan.mintInvocation` to obtain the bearer token. Failures are
+ * logged at `warn` and swallowed — the caller falls back to public-only.
+ */
+export declare function createDefaultSkillsUcanBuilder(): SkillsUcanBuilder;
+//# sourceMappingURL=skills-ucan.d.ts.map

package/dist/plugins/skills/skills-ucan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills-ucan.d.ts","sourceRoot":"","sources":["../../../src/plugins/skills/skills-ucan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,cAAc,KACnB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,8BAA8B,IAAI,iBAAiB,CAuBlE"}

package/dist/plugins/skills/skills-ucan.js

@@ -0,0 +1,28 @@
+/**
+ * Default {@link SkillsUcanBuilder}. Uses the same primitives as the sandbox
+ * plugin: `runCtx.ucan.resolveServiceDid` for did:web resolution +
+ * `runCtx.ucan.mintInvocation` to obtain the bearer token. Failures are
+ * logged at `warn` and swallowed — the caller falls back to public-only.
+ */
+export function createDefaultSkillsUcanBuilder() {
+    return async (skillsServiceUrl, runCtx) => {
+        const skillsDid = await runCtx.ucan.resolveServiceDid(skillsServiceUrl);
+        if (!skillsDid) {
+            return undefined;
+        }
+        try {
+            const invocation = await runCtx.ucan.mintInvocation({
+                did: skillsDid,
+                capability: 'ixo:skills',
+            });
+            return invocation || undefined;
+        }
+        catch (error) {
+            const detail = error instanceof Error
+                ? `${error.name}: ${error.message}`
+                : String(error);
+            runCtx.logger.warn(`[skills] failed to mint skills UCAN invocation: ${detail}`);
+            return undefined;
+        }
+    };
+}

package/dist/plugins/skills/skills.plugin.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { OraclePlugin } from '../../plugin-api/oracle-plugin.js';
+import type { PluginContext, PluginManifest, PluginTool } from '../../plugin-api/types.js';
+import { type SkillsUcanBuilder } from './skills-ucan.js';
+export interface SkillsPluginOptions {
+    /**
+     * Override the UCAN minting helper. Tests inject a stub here so the plugin
+     * never touches did:web resolution / the UCAN service; production code
+     * lets the default builder do the network work.
+     */
+    ucanBuilder?: SkillsUcanBuilder;
+}
+/**
+ * Skills plugin.
+ *
+ * Exposes `list_skills` and `search_skills` over the IXO skills registry
+ * (ai-skills). Both tools mint an `ixo:skills` UCAN invocation per call so
+ * the registry can surface the caller's own published private skills
+ * alongside the public ones. When minting fails the tools degrade to
+ * public-only — they never throw on auth issues.
+ *
+ * Hard-depends on the sandbox plugin: skill *execution* runs through
+ * `sandbox_run`, which the sandbox plugin owns. Listing/search is HTTP-only.
+ */
+export declare class SkillsPlugin extends OraclePlugin {
+    readonly name = "skills";
+    readonly version = "1.0.0";
+    readonly manifest: PluginManifest;
+    readonly dependsOn: string[];
+    readonly configSchema: z.ZodObject<{
+        SKILLS_CAPSULES_BASE_URL: z.ZodDefault<z.ZodURL>;
+    }, z.core.$strip>;
+    private readonly ucanBuilderOverride?;
+    constructor(opts?: SkillsPluginOptions);
+    getTools(ctx: PluginContext): PluginTool[];
+}
+//# sourceMappingURL=skills.plugin.d.ts.map

package/dist/plugins/skills/skills.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.plugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/skills/skills.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,UAAU,EACX,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AA4C1B,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACjC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,YAAY;IAC5C,QAAQ,CAAC,IAAI,YAAY;IACzB,QAAQ,CAAC,OAAO,WAAW;IAC3B,QAAQ,CAAC,QAAQ,iBAAY;IAC7B,SAAkB,SAAS,WAAe;IAC1C,SAAkB,YAAY;;sBAAgB;IAE9C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAoB;gBAE7C,IAAI,GAAE,mBAAwB;IAKjC,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,UAAU,EAAE;CAwBpD"}

package/dist/plugins/skills/skills.plugin.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { OraclePlugin } from '../../plugin-api/oracle-plugin.js';
+import { createSkillsTools } from './skills-tools.js';
+import { createDefaultSkillsUcanBuilder, } from './skills-ucan.js';
+const DEFAULT_SKILLS_BASE_URL = 'https://capsules.skills.ixo.earth';
+const configSchema = z.object({
+    SKILLS_CAPSULES_BASE_URL: z.url().default(DEFAULT_SKILLS_BASE_URL),
+});
+/**
+ * Sibling env vars read at request time. `NETWORK` is owned by the core
+ * (Tier-0) base env schema and forwarded to ai-skills as the `X-IXO-Network`
+ * routing hint. Optional here — absent values fall back to `mainnet`.
+ */
+const siblingEnvSchema = z.object({
+    NETWORK: z.enum(['mainnet', 'testnet', 'devnet']).optional(),
+});
+const manifest = {
+    title: 'Skills',
+    summary: "Discover IXO skill capsules — the caller's published private skills first, then the public registry.",
+    whenToUse: [
+        'User asks "what skills are available?" or "what can you do?".',
+        'User asks the agent to find a skill for a specific task ("a skill for invoices", "is there a skill for KYC?").',
+        'Before running a skill via the sandbox, list or search to obtain its cid + path.',
+    ],
+    whenNotToUse: [
+        'Executing a skill — that goes through the Sandbox (`sandbox_run`), not the skills tools.',
+        'General web search (use Firecrawl).',
+    ],
+    examples: [
+        {
+            user: 'Do you have a skill that can generate an invoice?',
+            thought: 'Skill discovery — search the registry, then hand the cid+path off to sandbox_run for execution.',
+            tool: 'search_skills',
+        },
+    ],
+    tags: ['skills', 'capsules', 'registry', 'ucan'],
+    category: 'data',
+    visibility: 'always',
+    stability: 'stable',
+};
+/**
+ * Skills plugin.
+ *
+ * Exposes `list_skills` and `search_skills` over the IXO skills registry
+ * (ai-skills). Both tools mint an `ixo:skills` UCAN invocation per call so
+ * the registry can surface the caller's own published private skills
+ * alongside the public ones. When minting fails the tools degrade to
+ * public-only — they never throw on auth issues.
+ *
+ * Hard-depends on the sandbox plugin: skill *execution* runs through
+ * `sandbox_run`, which the sandbox plugin owns. Listing/search is HTTP-only.
+ */
+export class SkillsPlugin extends OraclePlugin {
+    name = 'skills';
+    version = '1.0.0';
+    manifest = manifest;
+    dependsOn = ['sandbox'];
+    configSchema = configSchema;
+    ucanBuilderOverride;
+    constructor(opts = {}) {
+        super();
+        this.ucanBuilderOverride = opts.ucanBuilder;
+    }
+    getTools(ctx) {
+        const parsed = configSchema.safeParse(ctx.config);
+        if (!parsed.success) {
+            throw new Error(`skills: invalid configuration: ${parsed.error.issues
+                .map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`)
+                .join('; ')}`);
+        }
+        const siblings = siblingEnvSchema.safeParse(ctx.config);
+        const network = siblings.success
+            ? (siblings.data.NETWORK ?? 'mainnet')
+            : 'mainnet';
+        const ucanBuilder = this.ucanBuilderOverride ?? createDefaultSkillsUcanBuilder();
+        return createSkillsTools({
+            baseUrl: parsed.data.SKILLS_CAPSULES_BASE_URL,
+            network,
+            ucanBuilder,
+        });
+    }
+}

package/dist/plugins/slack/index.d.ts

@@ -0,0 +1,4 @@
+export { SlackPlugin } from './slack.plugin.js';
+export { SlackModule } from './slack.module.js';
+export { SlackService } from './slack.service.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/slack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/slack/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/plugins/slack/index.js

@@ -0,0 +1,3 @@
+export { SlackPlugin } from './slack.plugin.js';
+export { SlackModule } from './slack.module.js';
+export { SlackService } from './slack.service.js';

package/dist/plugins/slack/slack.module.d.ts

@@ -0,0 +1,9 @@
+/**
+ * NestJS module shipping `SlackService`. Imported by `RuntimeAppModule` when
+ * the slack plugin is loaded — the plugin returns this class from its
+ * `getNestModules()` hook. `OnModuleInit` opens the Slack socket; the
+ * Tier-0 messages/sessions modules supply the DI it needs.
+ */
+export declare class SlackModule {
+}
+//# sourceMappingURL=slack.module.d.ts.map

package/dist/plugins/slack/slack.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.module.d.ts","sourceRoot":"","sources":["../../../src/plugins/slack/slack.module.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,qBAMa,WAAW;CAAG"}

package/dist/plugins/slack/slack.module.js

@@ -0,0 +1,27 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Global, Module } from '@nestjs/common';
+import { MessagesModule } from '../../modules/messages/messages.module.js';
+import { SessionsModule } from '../../modules/sessions/sessions.module.js';
+import { SlackService } from './slack.service.js';
+/**
+ * NestJS module shipping `SlackService`. Imported by `RuntimeAppModule` when
+ * the slack plugin is loaded — the plugin returns this class from its
+ * `getNestModules()` hook. `OnModuleInit` opens the Slack socket; the
+ * Tier-0 messages/sessions modules supply the DI it needs.
+ */
+let SlackModule = class SlackModule {
+};
+SlackModule = __decorate([
+    Global(),
+    Module({
+        providers: [SlackService],
+        exports: [SlackService],
+        imports: [MessagesModule, SessionsModule],
+    })
+], SlackModule);
+export { SlackModule };

package/dist/plugins/slack/slack.plugin.d.ts

@@ -0,0 +1,30 @@
+import type { Type } from '@nestjs/common';
+import { z } from 'zod';
+import { OraclePlugin } from '../../plugin-api/oracle-plugin.js';
+import type { PluginManifest } from '../../plugin-api/types.js';
+/**
+ * Slack transport plugin. Ships its own NestJS module so the bot client can
+ * use `OnModuleInit`/`OnModuleDestroy` for socket-mode lifecycle and inject
+ * the Tier-0 services it needs (messages, sessions, cache). The plugin
+ * itself contributes no agent-visible tools — slack is purely a transport.
+ *
+ * Auto-detects via `SLACK_BOT_OAUTH_TOKEN`; if the token is missing the
+ * plugin is skipped at boot and no module is registered.
+ */
+export declare class SlackPlugin extends OraclePlugin {
+    static readonly NAME = "slack";
+    readonly name = "slack";
+    readonly version = "1.0.0";
+    readonly manifest: PluginManifest;
+    readonly configSchema: z.ZodObject<{
+        SLACK_BOT_OAUTH_TOKEN: z.ZodString;
+        SLACK_APP_TOKEN: z.ZodOptional<z.ZodString>;
+        SLACK_USE_SOCKET_MODE: z.ZodDefault<z.ZodString>;
+        SLACK_MAX_RECONNECT_ATTEMPTS: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        SLACK_RECONNECT_DELAY_MS: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+    readonly autoDetectHint = "SLACK_BOT_OAUTH_TOKEN";
+    autoDetect(env: NodeJS.ProcessEnv): boolean;
+    getNestModules(): Type[];
+}
+//# sourceMappingURL=slack.plugin.d.ts.map

package/dist/plugins/slack/slack.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.plugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/slack/slack.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAWhE;;;;;;;;GAQG;AACH,qBAAa,WAAY,SAAQ,YAAY;IAC3C,MAAM,CAAC,QAAQ,CAAC,IAAI,WAAW;IAE/B,QAAQ,CAAC,IAAI,WAAoB;IAEjC,QAAQ,CAAC,OAAO,WAAW;IAE3B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAQ/B;IAEF,SAAkB,YAAY;;;;;;sBAAgB;IAE9C,SAAkB,cAAc,2BAA2B;IAElD,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,OAAO;IAI3C,cAAc,IAAI,IAAI,EAAE;CAGlC"}

package/dist/plugins/slack/slack.plugin.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { OraclePlugin } from '../../plugin-api/oracle-plugin.js';
+import { SlackModule } from './slack.module.js';
+const configSchema = z.object({
+    SLACK_BOT_OAUTH_TOKEN: z.string(),
+    SLACK_APP_TOKEN: z.string().optional(),
+    SLACK_USE_SOCKET_MODE: z.string().default('true'),
+    SLACK_MAX_RECONNECT_ATTEMPTS: z.coerce.number().default(10),
+    SLACK_RECONNECT_DELAY_MS: z.coerce.number().default(1000),
+});
+/**
+ * Slack transport plugin. Ships its own NestJS module so the bot client can
+ * use `OnModuleInit`/`OnModuleDestroy` for socket-mode lifecycle and inject
+ * the Tier-0 services it needs (messages, sessions, cache). The plugin
+ * itself contributes no agent-visible tools — slack is purely a transport.
+ *
+ * Auto-detects via `SLACK_BOT_OAUTH_TOKEN`; if the token is missing the
+ * plugin is skipped at boot and no module is registered.
+ */
+export class SlackPlugin extends OraclePlugin {
+    static NAME = 'slack';
+    name = SlackPlugin.NAME;
+    version = '1.0.0';
+    manifest = {
+        title: 'Slack',
+        summary: 'Slack bot transport — runs as a NestJS module with socket-mode lifecycle.',
+        whenToUse: [],
+        visibility: 'silent',
+        stability: 'stable',
+        category: 'core',
+    };
+    configSchema = configSchema;
+    autoDetectHint = 'SLACK_BOT_OAUTH_TOKEN';
+    autoDetect(env) {
+        return Boolean(env.SLACK_BOT_OAUTH_TOKEN);
+    }
+    getNestModules() {
+        return [SlackModule];
+    }
+}

package/dist/plugins/slack/slack.service.d.ts

@@ -0,0 +1,32 @@
+import { type OnModuleDestroy, type OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import type { Cache } from 'cache-manager';
+import { MessagesService } from '../../modules/messages/messages.service.js';
+import { SessionsService } from '../../modules/sessions/sessions.service.js';
+export declare class SlackService implements OnModuleInit, OnModuleDestroy {
+    private readonly configService;
+    private readonly messagesService;
+    private readonly cacheManager;
+    private readonly sessionsService;
+    private readonly logger;
+    private slackInstance?;
+    private readonly isConfigured;
+    constructor(configService: ConfigService, messagesService: MessagesService, cacheManager: Cache, sessionsService: SessionsService);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    /** Connection status for health checks. */
+    getStatus(): {
+        isConnected: boolean;
+        connectionStats: {
+            isConnected: boolean;
+            reconnectAttempts: number;
+            maxReconnectAttempts: number;
+            mode: 'socket' | 'http';
+        };
+        isConfigured: boolean;
+    };
+    private getCachedSessionPerThread;
+    private getOrCreateSessionPerThread;
+    private onMessageHandler;
+}
+//# sourceMappingURL=slack.service.d.ts.map

package/dist/plugins/slack/slack.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.service.d.ts","sourceRoot":"","sources":["../../../src/plugins/slack/slack.service.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAE7E,qBACa,YAAa,YAAW,YAAY,EAAE,eAAe;IAM9D,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IACT,OAAO,CAAC,QAAQ,CAAC,YAAY;IACpD,OAAO,CAAC,QAAQ,CAAC,eAAe;IARlC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,aAAa,CAAC,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAU;gBAGpB,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EACT,YAAY,EAAE,KAAK,EAC1C,eAAe,EAAE,eAAe;IAiC7C,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB7B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAYtC,2CAA2C;IAC3C,SAAS,IAAI;QACX,WAAW,EAAE,OAAO,CAAC;QACrB,eAAe,EAAE;YACf,WAAW,EAAE,OAAO,CAAC;YACrB,iBAAiB,EAAE,MAAM,CAAC;YAC1B,oBAAoB,EAAE,MAAM,CAAC;YAC7B,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;SACzB,CAAC;QACF,YAAY,EAAE,OAAO,CAAC;KACvB;YAqBa,yBAAyB;YAOzB,2BAA2B;IAgCzC,OAAO,CAAC,gBAAgB;CA8BzB"}

package/dist/plugins/slack/slack.service.js

@@ -0,0 +1,157 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var SlackService_1;
+import { Slack } from '@ixo/slack';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable, Logger, } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { MessagesService } from '../../modules/messages/messages.service.js';
+import { SessionsService } from '../../modules/sessions/sessions.service.js';
+let SlackService = SlackService_1 = class SlackService {
+    configService;
+    messagesService;
+    cacheManager;
+    sessionsService;
+    logger = new Logger(SlackService_1.name);
+    slackInstance;
+    isConfigured;
+    constructor(configService, messagesService, cacheManager, sessionsService) {
+        this.configService = configService;
+        this.messagesService = messagesService;
+        this.cacheManager = cacheManager;
+        this.sessionsService = sessionsService;
+        const botToken = configService.get('SLACK_BOT_OAUTH_TOKEN');
+        const appToken = configService.get('SLACK_APP_TOKEN');
+        const useSocketMode = true;
+        this.isConfigured = Boolean(botToken);
+        if (!botToken) {
+            this.logger.warn('SLACK_BOT_OAUTH_TOKEN not provided — Slack integration will be disabled');
+            return;
+        }
+        if (useSocketMode && !appToken) {
+            this.logger.error('SLACK_APP_TOKEN is required when SLACK_USE_SOCKET_MODE=true');
+            throw new Error('SLACK_APP_TOKEN is required when SLACK_USE_SOCKET_MODE=true');
+        }
+        try {
+            this.slackInstance = new Slack(botToken, appToken ?? '', {
+                useSocketMode,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize Slack instance:', error);
+            throw error;
+        }
+    }
+    async onModuleInit() {
+        if (!this.slackInstance) {
+            this.logger.warn('Slack not configured — skipping initialization');
+            return;
+        }
+        try {
+            const useSocketMode = this.configService.get('SLACK_USE_SOCKET_MODE') === 'true';
+            const mode = useSocketMode ? 'Socket Mode' : 'HTTP Mode';
+            this.logger.log(`Initializing Slack ${mode} connection...`);
+            this.onMessageHandler();
+            await this.slackInstance.start();
+            this.logger.log(`Slack ${mode} connection initialized successfully`);
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize Slack:', error);
+            this.logger.warn('Continuing without Slack integration');
+        }
+    }
+    async onModuleDestroy() {
+        if (!this.slackInstance)
+            return;
+        try {
+            this.logger.log('Shutting down Slack connection...');
+            await this.slackInstance.stop();
+            this.logger.log('Slack connection shut down successfully');
+        }
+        catch (error) {
+            this.logger.error('Error shutting down Slack:', error);
+        }
+    }
+    /** Connection status for health checks. */
+    getStatus() {
+        if (!this.isConfigured || !this.slackInstance) {
+            return {
+                isConnected: false,
+                connectionStats: {
+                    isConnected: false,
+                    reconnectAttempts: 0,
+                    maxReconnectAttempts: 0,
+                    mode: 'http',
+                },
+                isConfigured: false,
+            };
+        }
+        return {
+            isConnected: this.slackInstance.isConnected(),
+            connectionStats: this.slackInstance.getConnectionStats(),
+            isConfigured: true,
+        };
+    }
+    async getCachedSessionPerThread(threadTs) {
+        const cacheKey = `session:${threadTs}`;
+        return this.cacheManager.get(cacheKey);
+    }
+    async getOrCreateSessionPerThread(threadTs, userDid) {
+        const cachedSession = await this.getCachedSessionPerThread(threadTs);
+        if (cachedSession)
+            return cachedSession;
+        const sessions = await this.sessionsService.listSessions({ did: userDid });
+        const targetSession = sessions.sessions.find((s) => s.slackThreadTs === threadTs);
+        if (targetSession) {
+            void this.cacheManager.set(`session:${threadTs}`, targetSession, 5 * 60 * 1000);
+            return targetSession;
+        }
+        const newSession = await this.sessionsService.createSession({
+            did: userDid,
+            slackThreadTs: threadTs,
+        });
+        void this.cacheManager.set(`session:${threadTs}`, newSession, 5 * 60 * 1000);
+        return newSession;
+    }
+    onMessageHandler() {
+        if (!this.slackInstance?.app)
+            return;
+        this.slackInstance.app.message(async ({ message, say }) => {
+            this.logger.debug('Message received', { message });
+            if (message.type === 'message' &&
+                message.subtype === undefined &&
+                typeof message.text === 'string') {
+                const userDid = 'did:ixo:ixo100jprv3ap66prgdvyuxhuynhp2muv0pclyx4l7';
+                const threadTs = message.thread_ts ?? message.ts;
+                const session = await this.getOrCreateSessionPerThread(threadTs, userDid);
+                const aiMessage = await this.messagesService.sendMessage({
+                    did: userDid,
+                    message: message.text,
+                    sessionId: session.sessionId,
+                });
+                void say({
+                    text: aiMessage?.message.content ?? '',
+                    thread_ts: threadTs,
+                });
+            }
+        });
+        this.logger.log('Slack message handler registered');
+    }
+};
+SlackService = SlackService_1 = __decorate([
+    Injectable(),
+    __param(2, Inject(CACHE_MANAGER)),
+    __metadata("design:paramtypes", [ConfigService,
+        MessagesService, Object, SessionsService])
+], SlackService);
+export { SlackService };

package/dist/plugins/user-preferences/index.d.ts

@@ -0,0 +1,4 @@
+export { UserPreferencesPlugin, type UserPreferencesPluginService, } from './user-preferences.plugin.js';
+export { UserPreferencesService, UserPreferencesSchema, USER_PREFS_STATE_KEY, type UserPreferences, type UserPreferencesReader, type UserPreferencesWriter, } from './service/user-preferences.service.js';
+export { createSetUserPreferencesTool, type CreateSetUserPreferencesToolOptions, } from './user-preferences-tool.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/user-preferences/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/user-preferences/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,GAC3B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,4BAA4B,EAC5B,KAAK,mCAAmC,GACzC,MAAM,4BAA4B,CAAC"}

package/dist/plugins/user-preferences/index.js

@@ -0,0 +1,3 @@
+export { UserPreferencesPlugin, } from './user-preferences.plugin.js';
+export { UserPreferencesService, UserPreferencesSchema, USER_PREFS_STATE_KEY, } from './service/user-preferences.service.js';
+export { createSetUserPreferencesTool, } from './user-preferences-tool.js';

package/dist/plugins/user-preferences/service/user-preferences.service.d.ts

@@ -0,0 +1,61 @@
+import type { Cache } from 'cache-manager';
+import { z } from 'zod';
+export declare const USER_PREFS_STATE_KEY = "user_prefs";
+export declare const UserPreferencesSchema: z.ZodObject<{
+    agentName: z.ZodOptional<z.ZodString>;
+    userName: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    tone: z.ZodOptional<z.ZodString>;
+    formality: z.ZodOptional<z.ZodEnum<{
+        casual: "casual";
+        friendly: "friendly";
+        neutral: "neutral";
+        "semi-formal": "semi-formal";
+        professional: "professional";
+        formal: "formal";
+        technical: "technical";
+        academic: "academic";
+    }>>;
+    customInstructions: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type UserPreferences = z.infer<typeof UserPreferencesSchema>;
+/**
+ * Stores per-room user preferences in Matrix room state, with an optional
+ * in-memory cache. The singleton is consumed by the user-preferences
+ * middleware which loads prefs into `state.userPreferences` on every request.
+ */
+export declare class UserPreferencesService {
+    private static instance;
+    private cacheManager;
+    private constructor();
+    static getInstance(): UserPreferencesService;
+    setCacheManager(cache: Cache): void;
+    private cacheKey;
+    /**
+     * Read user preferences for a given room.
+     * Returns undefined if no preferences have been set, or if anything goes wrong
+     * (we never want missing prefs to break a chat session).
+     */
+    get(roomId: string): Promise<UserPreferences | undefined>;
+    /**
+     * Merge `partial` into the existing preferences, write to Matrix room state,
+     * invalidate the cache, and return the merged result.
+     * `updatedAt` is always set by this service.
+     */
+    set(roomId: string, partial: Partial<UserPreferences>): Promise<UserPreferences>;
+    invalidate(roomId: string): Promise<void>;
+}
+/**
+ * Narrow contract over `UserPreferencesService` exposing only the read path.
+ * The middleware depends on this so tests can swap in a stub without
+ * instantiating the full Matrix-backed singleton.
+ */
+export type UserPreferencesReader = Pick<UserPreferencesService, 'get'>;
+/**
+ * Narrow contract over `UserPreferencesService` exposing only the write path.
+ * The `set_user_preferences` tool depends on this so tests can swap in a
+ * stub without instantiating the full Matrix-backed singleton.
+ */
+export type UserPreferencesWriter = Pick<UserPreferencesService, 'set'>;
+//# sourceMappingURL=user-preferences.service.d.ts.map

package/dist/plugins/user-preferences/service/user-preferences.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-preferences.service.d.ts","sourceRoot":"","sources":["../../../../src/plugins/user-preferences/service/user-preferences.service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAmBhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE;;;;GAIG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAyB;IAEhD,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,sBAAsB;IAO5C,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAInC,OAAO,CAAC,QAAQ;IAIhB;;;;OAIG;IACG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAoC/D;;;;OAIG;IACG,GAAG,CACP,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAChC,OAAO,CAAC,eAAe,CAAC;IAwBrB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGhD;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;AAExE;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC"}