dsh-aimail 0.1.0-rc.9 → 0.1.7

package/README.md

@@ -0,0 +1,60 @@
+# dsh-aimail
+
+AIMail plugin for dsh (deepseek-harness). It gives a dsh agent a mailbox on
+AIMail: inbound email is delivered into the agent's session, and the agent
+can send mail, manage contacts, keep thread notes, and work on A2A boards
+through 13 plain tools.
+
+## Install
+
+Prerequisites:
+
+- dsh (deepseek-harness) with the web profile
+- an AIMail binding for the dsh session (`aimail install` from the
+  aimail repo sets up `aimail_gateway.json` and per-address
+  `agentmail.json`)
+
+```bash
+# install (idempotent)
+dsh plugin --profile web add dsh-aimail
+
+# uninstall (idempotent)
+dsh plugin --profile web remove dsh-aimail
+```
+
+## What it does
+
+**Tools** — the same 13 bare-name tools as every other adapter:
+`send_mail`, `manage_contacts`, `contact_profile`, `set_contact_profile`,
+`email_summary`, `set_email_summary`, `search_mail`,
+`board_status`, `board_task_list`, `board_task_show`, `board_heartbeat`,
+`board_members`, `set_public_whoami`.
+Identity comes from the session id resolved through `@aimail/mail`
+(`agentmail.json` is the sole identity source); unbound sessions fail loud.
+
+**Inbound mail** — a profile-scoped HTTP endpoint (`POST /aimail/inbound`,
+default port `9099`, override with `AIMAIL_INBOUND_PORT`). Each bridge
+delivery is HMAC verified against the per-agent secret, enriched by the
+shared preprocess chain, and
+delivered to the agent's session (live followup, cold resume, or a fresh
+session bound for the turn).
+
+**Persona** — mounts an email-agent persona that teaches the model the mail
+workflow (reply-all semantics, tool selection, thread continuity).
+
+
+## Other adapters
+
+The same tool surface and inbound contract, bound to other agent platforms:
+
+- [openclaw-aimail](https://www.npmjs.com/package/openclaw-aimail) — AIMail plugin for OpenClaw — definePluginEntry: 13 tools, in-gateway HTTP route, register/status commands.
+- [pi-aimail](https://www.npmjs.com/package/pi-aimail) — AIMail extension for pi (earendil-works/pi) — registerTool tools + local inbound listener bridged via sendUserMessage.
+
+## Related repositories
+
+- [metercai/aimail](https://github.com/metercai/aimail) — the AIMail monorepo:
+  CLI (`cli/`), Python SDK (`pysdk/`), TypeScript SDK (`tssdk/`), bridge
+  distributions.
+- [metercai/aimail-gateway](https://github.com/metercai/aimail-gateway) — the
+  AIMail gateway: SMTP/HTTP mail service, address & activation APIs, and the
+  board endpoints the tools talk to.

package/cordis.patch.yml

@@ -1,26 +1,38 @@
-# agentmail bundle layer — mounted via `dsh plugin --profile web add agentmail`.
-# Entry list identical to the mail preset: persona + host services + tools.
+# dsh-aimail bundle layer — mounted via `dsh plugin --profile web add dsh-aimail`.
+# Self-mounting: all entries resolve to subpaths of this very package
+# (package.json "exports"), so the bundle needs no sibling @aimail/* packages.
+#
+# Patch dialect (dsh-app-boot): rows that exist in an earlier layer (dsh-base)
+# are targeted by id and their whole `config` is replaced; rows new to this
+# bundle are added under `insert:`. Targeting an absent row only warns.
 
 # ── identity ────────────────────────────────────────────────────────────────
+# Base owns the `system-prompt` row (config.persona defaults to ''). We replace
+# it to set this deployment's persona. (dsh-persona is a scope-only row for
+# agent presets — mounting it globally fails loud, so it is not used here.)
 
-- id: persona
-  name: '@deepseek-ai/dsh-persona'
+- id: system-prompt
   config:
-    text: >-
-      You are an email-capable agent on AgentMail. Use send_mail to reply to
+    persona: >-
+      You are an email-capable agent on AIMail. Use send_mail to reply to
       inbound mail; manage_contacts for your whitelist; contact_profile /
       set_contact_profile for contact context; email_summary /
       set_email_summary for thread notes; board_* tools for A2A board work.
 
-# ── AgentMail host services ─────────────────────────────────────────────────
+# ── rows new to this bundle ─────────────────────────────────────────────────
 
-- id: mail
-  name: '@meterwei/mail'
+- insert:
+    # AIMail host service (ctx.mail)
+    - id: mail
+      name: 'dsh-aimail/mail-service'
 
-- id: mail-inbound
-  name: '@meterwei/mail-inbound'
+    # AIMail inbound endpoint (node:http + session delivery). Port is fixed:
+    # single consumer (this profile); the local bridge routes here.
+    - id: mail-inbound
+      name: 'dsh-aimail/inbound'
+      config:
+        port: 9099
 
-# ── AgentMail tools (bare names) ────────────────────────────────────────────
-
-- id: tool-mail
-  name: '@meterwei/tool-mail'
+    # AIMail tools (12 bare names, semantics from @aimail/mail-core)
+    - id: tool-mail
+      name: 'dsh-aimail/tools'

package/lib/inbound.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "mail-inbound";
+export declare const inject: string[];
+export interface Config {
+    /** Listen host (default 127.0.0.1). */
+    host?: string;
+    /** Listen port (default AIMAIL_INBOUND_PORT or 9099). */
+    port?: number;
+    /** Deliver path (default /aimail/inbound). */
+    path?: string;
+}
+export declare function apply(ctx: Context, config?: Config): () => void;
+//# sourceMappingURL=inbound.d.ts.map

package/lib/inbound.js

@@ -0,0 +1,179 @@
+/**
+ * dsh-aimail inbound — AIMail inbound endpoint for this profile.
+ *
+ * node:http listener (headless-friendly). Receives bridge-forwarded raw
+ * webhook bodies at POST {path} (default /aimail/inbound):
+ *   recipient routing (resolveByRecipient: exact → persona-strip fallback)
+ *   → HMAC verify (X-Webhook-Signature vs webhook_secret from agentmail.json)
+ *   → TS preprocess chain (mail-core, DSH-PREPROCESS-CONTRACT.md)
+ *   → ping/pong intercept (three-stage logs, swallowed)
+ *   → un-intercepted: deliver to the bound dsh session (live followup, cold
+ *     resume) or spawn a fresh disposable session when unbound — context
+ *     continuity is aimail's (local meta threading), not the session's.
+ *     200 ack on delivery; 503 on session-create failure (bridge retries).
+ */
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { processInboundMail, verifySignature, routeAddressFromHeaders, updateAgentConfig, loadAgentConfig, saveAgentConfig } from '@aimail/mail-core';
+export const name = 'mail-inbound';
+export const inject = ['mail', 'agents'];
+function writeJson(res, code, body) {
+    const text = JSON.stringify(body);
+    res.writeHead(code, { 'Content-Type': 'application/json' });
+    res.end(text);
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+export function apply(ctx, config = {}) {
+    const mail = ctx.get('mail');
+    if (mail === undefined) {
+        throw new Error('mail-inbound requires the mail service: mount dsh-aimail/mail-service first');
+    }
+    const host = config.host ?? '127.0.0.1';
+    const port = config.port ?? Number(process.env.AIMAIL_INBOUND_PORT ?? 9099);
+    const deliverPath = config.path ?? '/aimail/inbound';
+    const server = createServer(async (req, res) => {
+        try {
+            if (req.method !== 'POST' || (req.url ?? '').split('?')[0] !== deliverPath) {
+                writeJson(res, 404, { status: 'not_found' });
+                return;
+            }
+            const rawBody = await readBody(req);
+            let payload;
+            try {
+                payload = JSON.parse(rawBody.toString('utf-8'));
+            }
+            catch {
+                writeJson(res, 400, { status: 'bad_json' });
+                return;
+            }
+            // Inbound routing (Q3 — mirror Python bridge routing): the per-delivery
+            // target is authoritative. The bridge injects X-AIMail-Email (legacy
+            // X-Amail-Email fallback) on each single-delivery POST; payload.to is
+            // the FILTERED full list (external recipients first), so to[0] is often
+            // an external address. Use the header when present; only iterate toRaw
+            // when the header is absent (batch deliveries carry no such header).
+            const headers = {
+                ...req.headers,
+                ...(payload.headers ?? {}),
+            };
+            const routeAddr = routeAddressFromHeaders(headers);
+            const toRaw = Array.isArray(payload.to) ? payload.to : typeof payload.to === 'string' ? [payload.to] : [];
+            const routeCandidates = routeAddr ? [routeAddr] : toRaw;
+            let cfg;
+            let agentAddr = '';
+            for (const t of routeCandidates) {
+                const addr = String(t).trim();
+                if (!addr.includes('@'))
+                    continue;
+                const c = await mail.resolveByRecipient(addr);
+                if (c) {
+                    cfg = c;
+                    agentAddr = addr;
+                    break;
+                }
+            }
+            if (!cfg) {
+                writeJson(res, 200, { status: 'no_agent', detail: `no binding for ${routeAddr || toRaw.join(',')}` });
+                return;
+            }
+            // HMAC verify (per-address webhook_secret)
+            const sig = req.headers['x-webhook-signature'] ?? '';
+            if (!verifySignature(rawBody, sig, cfg.webhook_secret ?? '')) {
+                writeJson(res, 401, { status: 'bad_signature' });
+                return;
+            }
+            // TS preprocess chain (13 steps) + ping/pong intercept
+            const result = await processInboundMail(payload, headers, {
+                systemId: cfg.system_id,
+                email: cfg.email,
+            });
+            if (result === null) {
+                writeJson(res, 200, { status: 'intercepted' });
+                return;
+            }
+            // Deliver to a dsh session:
+            //  - cfg.session_id set + live  → followup that session (UI continuity)
+            //  - cfg.session_id set + cold  → resume it, else fall through
+            //  - unbound (or resume failed) → spawn a FRESH session. Context
+            //    continuity is aimail's job (local meta threading + email_summary),
+            //    not the session's — per the deployment decision each inbound email
+            //    gets its own disposable session.
+            const agents = ctx.get('agents');
+            if (agents === undefined) {
+                writeJson(res, 200, { status: 'no_agents_service', detail: 'dsh-agent not mounted' });
+                return;
+            }
+            // Model route: the deployment's default selection (base bundle's
+            // `agent-default-model` row, e.g. deepseek-official/deepseek-v4-flash)
+            // — same source the web UI's api-proxy uses for agents.create().
+            // Without it the turn dies with "no provider/model".
+            const agentOptions = ctx.get('agentDefaultModel')
+                ?.currentSelection();
+            const boundId = cfg.session_id ?? '';
+            const message = createUserMessage({
+                content: [{ type: 'text', text: JSON.stringify({ ...result, to: agentAddr }) }],
+                source: { kind: 'user' },
+            });
+            const live = boundId ? agents.get(boundId) : undefined;
+            if (live) {
+                live.followup(message);
+                writeJson(res, 200, { status: 'delivered', detail: 'followup queued' });
+                return;
+            }
+            if (boundId) {
+                try {
+                    const handle = await agents.resume({ resumeSessionId: boundId, agentOptions });
+                    handle.agent.followup(message);
+                    writeJson(res, 200, { status: 'resumed', detail: 'cold session resumed + followup queued' });
+                    return;
+                }
+                catch {
+                    // resume failed (no persistence, stale id) — fall through to a fresh session
+                }
+            }
+            // Fresh disposable session for this email.
+            const sessionId = randomUUID();
+            try {
+                // Bind this session into the agent's config so the mail tools can
+                // resolve credentials (resolveBySessionId matches agentmail.json's
+                // session_id). Unbind again once the turn settles — but only if the
+                // binding is still OURS (a concurrent email may have re-bound).
+                await updateAgentConfig(cfg.system_id, cfg.email, { session_id: sessionId });
+                const handle = await agents.create({ sessionId, meta: { cwd: process.cwd() }, agentOptions });
+                handle.agent.followup(message);
+                void handle.agent.whenIdle()
+                    .then(async () => {
+                    const cur = await loadAgentConfig(cfg.system_id, cfg.email);
+                    if (cur && cur.session_id === sessionId) {
+                        const { session_id: _drop, ...rest } = cur;
+                        await saveAgentConfig(rest, cfg.system_id);
+                    }
+                })
+                    .then(() => handle.dispose())
+                    .catch(() => { });
+                writeJson(res, 200, { status: 'delivered', detail: `fresh session ${sessionId}` });
+            }
+            catch (e) {
+                // 503 (not 2xx) so the bridge does NOT ack and will retry; a 200 here
+                // would silently swallow the email.
+                writeJson(res, 503, { status: 'session_create_failed', detail: e instanceof Error ? e.message : String(e) });
+            }
+        }
+        catch (e) {
+            writeJson(res, 500, { status: 'error', detail: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    server.listen(port, host);
+    return () => {
+        server.close();
+    };
+}
+//# sourceMappingURL=inbound.js.map

package/lib/index.d.ts

@@ -1,8 +1,15 @@
 /**
- * agentmail — dsh bundle entry. The bundle patch (cordis.patch.yml) mounts
- * mail / mail-inbound / tool-mail + persona; this entry exposes the shared
- * core API for programmatic use. Installed via:
- *   dsh plugin --profile web add agentmail
+ * dsh-aimail — AIMail plugin for dsh (single self-contained bundle).
+ *
+ * The bundle patch (cordis.patch.yml) self-mounts three subpath entries:
+ *   dsh-aimail/mail-service  → ctx.mail (config resolution binding)
+ *   dsh-aimail/tools         → 12 AIMail bare tools
+ *   dsh-aimail/inbound       → node:http inbound endpoint + delivery
+ *
+ * Installed via: dsh plugin --profile web add dsh-aimail
+ * This entry re-exports the shared core API for programmatic use.
  */
-export * from '@meterwei/mail-core';
+export * from '@aimail/mail-core';
+export * from '@aimail/mail';
+export { type MailService } from './mail-service.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,8 +1,15 @@
 /**
- * agentmail — dsh bundle entry. The bundle patch (cordis.patch.yml) mounts
- * mail / mail-inbound / tool-mail + persona; this entry exposes the shared
- * core API for programmatic use. Installed via:
- *   dsh plugin --profile web add agentmail
+ * dsh-aimail — AIMail plugin for dsh (single self-contained bundle).
+ *
+ * The bundle patch (cordis.patch.yml) self-mounts three subpath entries:
+ *   dsh-aimail/mail-service  → ctx.mail (config resolution binding)
+ *   dsh-aimail/tools         → 12 AIMail bare tools
+ *   dsh-aimail/inbound       → node:http inbound endpoint + delivery
+ *
+ * Installed via: dsh plugin --profile web add dsh-aimail
+ * This entry re-exports the shared core API for programmatic use.
  */
-export * from '@meterwei/mail-core';
+export * from '@aimail/mail-core';
+export * from '@aimail/mail';
+export {} from './mail-service.js';
 //# sourceMappingURL=index.js.map

package/lib/mail-service.d.ts

@@ -0,0 +1,39 @@
+/**
+ * dsh-aimail mail service — provides ctx.mail to this bundle's tools/inbound
+ * entries. Thin dsh binding over the platform-neutral @aimail/mail resolvers
+ * (sessionId/email/recipient → agentmail.json → AgentConfig).
+ *
+ * Identity = agentmail.json only; the AIMAIL_SYSTEM_ID env narrows scope.
+ *
+ * Auto-bind (SDK auto-binding): a session resolution that finds no binding
+ * triggers one auto-bind attempt per (system, session) — register chain +
+ * agentmail.json + bridge route via mail-core autoBind, deriving the address
+ * `agent-<session8>.<system_name>@domain` — and retries the resolution. The
+ * once-guard means a failed attempt (gateway unreachable, no system config)
+ * never hammers the network on every tool call; the original unbound error
+ * is rethrown for the caller to handle.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type MailToolCtx } from '@aimail/mail';
+import { type AgentConfig } from '@aimail/mail-core';
+export declare const name = "mail";
+export declare const inject: never[];
+/** The ctx.mail service surface (consumed by the tools + inbound entries). */
+export interface MailService {
+    /** Optional explicit system scope (AIMAIL_SYSTEM_ID); empty = scan all. */
+    readonly systemId: string;
+    /** Resolve config for a dsh session id (uuid). Throws when unbound. */
+    resolveConfig(sessionId: string): Promise<AgentConfig>;
+    /** Resolve a tool context for a session id. Throws when unbound. */
+    resolveCtx(sessionId: string): Promise<MailToolCtx>;
+    /** Resolve config by the agent's registered email. Throws when unbound. */
+    resolveByEmail(email: string): Promise<AgentConfig>;
+    /** Inbound recipient routing: exact match → persona-strip fallback. */
+    resolveByRecipient(email: string): Promise<AgentConfig | undefined>;
+}
+/** Reset the once-guard (test hook / after an operator fixed the env). */
+export declare function resetAutoBindOnce(): void;
+export declare function apply(ctx: Context, config?: {
+    systemId?: string;
+}): void;
+//# sourceMappingURL=mail-service.d.ts.map

package/lib/mail-service.js

@@ -0,0 +1,139 @@
+import { resolveByRecipient, resolveByEmail, resolveBySessionId, } from '@aimail/mail';
+import { autoBind, emailForAgent, ensureSystem, hasAnySystem, listSystemDirs, readSystemConfig, releaseAllSystems, } from '@aimail/mail-core';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const name = 'mail';
+export const inject = [];
+/** Local inbound path the dsh-aimail/inbound entry listens on (default). */
+const INBOUND_PATH = '/aimail/inbound';
+/** The local receive endpoint registered as this session's webhook_url. */
+function inboundWebhookUrl() {
+    const fromEnv = (process.env.AIMAIL_INBOUND_URL ?? '').trim();
+    if (fromEnv)
+        return fromEnv.replace(/\/+$/, '') + INBOUND_PATH;
+    const port = Number(process.env.AIMAIL_INBOUND_PORT ?? 9099);
+    const p = Number.isInteger(port) && port > 0 ? port : 9099;
+    return `http://127.0.0.1:${p}${INBOUND_PATH}`;
+}
+/** Process once-guard per (system, session): at most one auto-bind attempt. */
+const _autoBindAttempted = new Set();
+/** Reset the once-guard (test hook / after an operator fixed the env). */
+export function resetAutoBindOnce() {
+    _autoBindAttempted.clear();
+}
+/**
+ * One-shot per-session auto-bind. Never throws — failures warn and fall
+ * through to the caller's original unbound error.
+ */
+async function tryAutoBindSession(systemId, sessionId) {
+    const key = `${systemId}:${sessionId}`;
+    if (_autoBindAttempted.has(key))
+        return undefined;
+    _autoBindAttempted.add(key);
+    try {
+        const gw = await readSystemConfig(systemId);
+        if (!gw.domain)
+            return undefined;
+        const short = sessionId.replace(/[^a-zA-Z0-9]/g, '').slice(0, 8) || 'session';
+        const email = emailForAgent(`agent-${short}`, gw.domain, gw.system_name ?? '');
+        const res = await autoBind({
+            systemId,
+            email,
+            webhookUrl: inboundWebhookUrl(),
+            extraFields: {
+                session_id: sessionId,
+                preset: process.env.AIMAIL_PRESET ?? 'mail',
+            },
+        });
+        if (!(res.registered || res.exists))
+            return undefined;
+        // Re-resolve: the binding now carries this session_id.
+        return await resolveBySessionId(sessionId, { systemId });
+    }
+    catch (e) {
+        console.warn(`[dsh-aimail] session auto-bind failed for ${sessionId}: ${e instanceof Error ? e.message : String(e)}`);
+        return undefined;
+    }
+}
+export function apply(ctx, config = {}) {
+    const systemId = config.systemId ?? process.env.AIMAIL_SYSTEM_ID ?? '';
+    // SDK-shipped board resources (role prompts/souls) → local config dir,
+    // so a dsh-only machine (no Python SDK/CLI) still gets them. Idempotent;
+    // never overwrites user-personalized files.
+    try {
+        releaseAllSystems(path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'resources', 'board'));
+    }
+    catch {
+        // non-fatal: resources are a seed; explicit release can re-run later
+    }
+    // install readiness: a dsh-only machine ensures its system through the CLI
+    // reverse-call ABI (`aimail ensure-system`, L1 only — never platform wiring,
+    // which is how the install↔plugin call loop stays acyclic). UNCONDITIONAL
+    // reverse-call (ownership short-circuit lives inside ensureSystem): a
+    // multi-platform machine with only ANOTHER platform's systems must still
+    // reach the CLI so this dsh profile binds its own system — gating on "any
+    // system exists" regressed that (AUDIT-1 P1-7). CLI missing → actionable
+    // bootstrap hint on stderr.
+    try {
+        const platformHome = process.env.AIMAIL_SYSTEM_HOME?.trim() ||
+            process.env.DSH_HOME?.trim() ||
+            path.join(os.homedir(), '.dsh');
+        void ensureSystem({ systemHome: platformHome })
+            .then((r) => {
+            if (r.ok) {
+                if (r.activated) {
+                    console.log(`[dsh-aimail] system activated: ${r.systemId}`);
+                }
+            }
+            else {
+                const hint = r.hint ? ` (${r.hint})` : '';
+                console.warn(`[dsh-aimail] no aimail system yet — ${r.error ?? 'unknown'}` + hint);
+            }
+        })
+            .catch((e) => {
+            console.warn(`[dsh-aimail] system ensure failed: ${e instanceof Error ? e.message : String(e)}`);
+        });
+    }
+    catch {
+        // non-fatal
+    }
+    /**
+     * Resolve a session config; on an unbound miss with a machine system
+     * config present, auto-bind that session once and retry.
+     */
+    const resolveOrAutoBindSession = async (sessionId) => {
+        if (!sessionId)
+            throw new Error('no session id to resolve aimail config');
+        try {
+            return await resolveBySessionId(sessionId, { systemId });
+        }
+        catch (e) {
+            if (!hasAnySystem())
+                throw e;
+            let target = systemId || process.env.AIMAIL_SYSTEM_ID || '';
+            if (!target) {
+                const sids = await listSystemDirs();
+                if (sids.length !== 1)
+                    throw e; // ambiguous scope — caller's error stands
+                target = sids[0];
+            }
+            const cfg = await tryAutoBindSession(target, sessionId);
+            if (cfg)
+                return cfg;
+            throw e;
+        }
+    };
+    const service = {
+        systemId,
+        resolveConfig: (sessionId) => resolveOrAutoBindSession(sessionId),
+        resolveCtx: async (sessionId) => {
+            const cfg = await resolveOrAutoBindSession(sessionId);
+            return { systemId: cfg.system_id, email: cfg.email };
+        },
+        resolveByEmail: (email) => resolveByEmail(email),
+        resolveByRecipient: (email) => resolveByRecipient(email),
+    };
+    ctx.provide('mail', service);
+}
+//# sourceMappingURL=mail-service.js.map

package/lib/tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * dsh-aimail tools — registers the 12 AIMail bare tools for this profile.
+ *
+ * Semantic text (names, descriptions, parameter descriptions) comes from
+ * the shared MAIL_TOOLS registry in @aimail/mail-core (single source of
+ * truth, parity-tested against amail_mcp_server.py). This adapter only:
+ *   - iterates MAIL_TOOLS, translating each entry to a dsh defineTool
+ *   - binds execution: exec.agent.id (dsh session uuid) → ctx.mail.resolveCtx
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "tool-mail";
+export declare const inject: string[];
+export declare function apply(ctx: Context, config?: {
+    identity?: string;
+}): void;
+//# sourceMappingURL=tools.d.ts.map

package/lib/tools.js

@@ -0,0 +1,76 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { MAIL_TOOLS, setAgentIdentity, setAgentModel, } from '@aimail/mail-core';
+export const name = 'tool-mail';
+export const inject = ['tools', 'mail'];
+function textRender(_args, value) {
+    return [{ type: 'text', text: JSON.stringify(value) }];
+}
+const jsonOutput = {
+    schema: { type: 'json' },
+    render: textRender,
+};
+/** ToolResult → JsonValue (output.schema contract). */
+const run = (p) => p;
+/**
+ * Translate the neutral MailToolParam into a dsh ParameterPropertySpec.
+ * dsh requires `required?: true` (never false) and per-type literal shapes,
+ * so optional fields are omitted rather than set to undefined/false.
+ */
+function toDshParam(p) {
+    const base = {};
+    if (p.type === 'string') {
+        base.type = 'string';
+        if (p.enum !== undefined)
+            base.enum = p.enum;
+    }
+    else {
+        base.type = 'array';
+        if (p.items !== undefined)
+            base.items = { type: p.items.type };
+    }
+    if (p.description !== undefined)
+        base.description = p.description;
+    if (p.required === true)
+        base.required = true;
+    return base;
+}
+export function apply(ctx, config = {}) {
+    const mail = ctx.get('mail');
+    if (mail === undefined) {
+        throw new Error('tool-mail requires the mail service: mount dsh-aimail/mail-service first');
+    }
+    if (config.identity)
+        setAgentIdentity(config.identity);
+    // Primary model: same deployment default the inbound router uses for
+    // agents.create() (cordis 'agentDefaultModel' service).
+    const adm = ctx.get('agentDefaultModel');
+    const sel = adm?.currentSelection?.();
+    const modelId = typeof sel === 'string'
+        ? sel
+        : sel?.model ?? sel?.id;
+    if (modelId)
+        setAgentModel(modelId);
+    const resolve = async (exec) => {
+        const sessionId = String(exec.agent?.id ?? '');
+        return mail.resolveCtx(sessionId);
+    };
+    for (const tool of MAIL_TOOLS) {
+        const { handler: _handler, ...semantic } = tool;
+        void _handler;
+        // Translate the neutral parameter schema into dsh's spec shape.
+        const parameters = {};
+        for (const [key, p] of Object.entries(semantic.parameters)) {
+            parameters[key] = toDshParam(p);
+        }
+        ctx.tools.register(defineTool({
+            name: semantic.name,
+            description: semantic.description,
+            parameters,
+            output: jsonOutput,
+            async execute(args, exec) {
+                return run(tool.handler(await resolve(exec), args));
+            },
+        }));
+    }
+}
+//# sourceMappingURL=tools.js.map