@xpert-ai/plugin-markitdown 0.0.1

package/README.md

@@ -0,0 +1,152 @@
+# Xpert Plugin: MarkItDown Middleware
+
+`@xpert-ai/plugin-markitdown` adds document-to-Markdown conversion support to Xpert agents by bootstrapping Microsoft's [MarkItDown](https://github.com/microsoft/markitdown) inside the agent sandbox and teaching the agent how to use it through `sandbox_shell`. The middleware prepares the sandbox runtime, injects MarkItDown usage guidance into the system prompt, and keeps the tool ready for on-demand file conversion.
+
+## Key Features
+
+- Bootstraps `markitdown` via pip inside the sandbox on first use.
+- Supports a wide range of file formats: **PDF, DOCX, PPTX, XLSX, HTML, CSV, JSON, XML, ZIP, images (JPEG/PNG), audio (MP3/WAV), EPUB, RSS**, and more.
+- Writes embedded skill assets (`SKILL.md` plus reference docs) into the sandbox for agent self-guidance.
+- Appends a MarkItDown-specific system prompt so the agent uses `sandbox_shell` with `markitdown` for file conversion.
+- Re-checks bootstrap state before MarkItDown shell commands and re-installs automatically if the sandbox container was reset.
+- Validates agent drafts and warns when sandbox support or `SandboxShell` is missing.
+- Configurable pip extras (`all`, `ocr`, `az-doc-intel`) to control which optional dependencies are installed.
+
+## Quick Start
+
+1. **Register the Plugin**  
+   Start Xpert with the package in your plugin list:
+   ```sh
+   PLUGINS=@xpert-ai/plugin-markitdown
+   ```
+   The plugin registers the global `MarkItDownPluginModule`.
+
+2. **Enable Sandbox Support**  
+   Turn on the agent sandbox feature for the team/agent that will perform file conversion.
+
+3. **Add `SandboxShell` on the Same Agent**  
+   This middleware relies on the `sandbox_shell` tool exposed by the `SandboxShell` middleware.
+
+4. **Add the MarkItDown Middleware**  
+   In the Xpert console (or agent definition), add a middleware entry with strategy `MarkItDownSkill`.
+
+5. **Optionally Configure the Bootstrap Behavior**  
+   Example middleware block:
+   ```json
+   {
+     "type": "MarkItDownSkill",
+     "options": {
+       "version": "latest",
+       "extras": "all",
+       "skillsDir": "/workspace/.xpert/skills/markitdown"
+     }
+   }
+   ```
+
+6. **Ask the Agent to Convert Files**  
+   Once configured, the agent can convert documents to Markdown:
+   ```
+   User: Please convert the uploaded report.pdf to Markdown.
+   Agent: (runs `markitdown report.pdf > report.md` via sandbox_shell)
+   ```
+
+## Configuration
+
+| Field | Type | Description | Default |
+| ----- | ---- | ----------- | ------- |
+| `version` | string | Version of `markitdown` to install via pip in the sandbox. | `"latest"` |
+| `extras` | string | Python extras to install (e.g. `"all"`, `"ocr"`, `"az-doc-intel"`). Use `"all"` for full functionality. | `"all"` |
+| `skillsDir` | string | Path inside the sandbox where `SKILL.md` and reference files are written. | `"/workspace/.xpert/skills/markitdown"` |
+
+## Supported File Formats
+
+| Format | Extensions | Notes |
+|--------|-----------|-------|
+| PDF | `.pdf` | Text extraction, layout preservation |
+| Word | `.docx` | Full structure: headings, tables, lists, images |
+| PowerPoint | `.pptx` | Slides, speaker notes, embedded content |
+| Excel | `.xlsx` | Sheets as Markdown tables |
+| HTML | `.html`, `.htm` | Web page content extraction |
+| CSV | `.csv` | Converted to Markdown tables |
+| JSON | `.json` | Structured representation |
+| XML | `.xml` | Structured representation |
+| Images | `.jpg`, `.jpeg`, `.png` | EXIF metadata, OCR (with extras) |
+| Audio | `.mp3`, `.wav` | Speech-to-text transcription |
+| ZIP | `.zip` | Recursively converts contained files |
+| EPUB | `.epub` | Book content extraction |
+| RSS/Atom | feeds | Feed entry extraction |
+
+## Runtime Behavior
+
+- On first use, the middleware checks `/workspace/.xpert/.markitdown-bootstrap.json` to determine whether the sandbox is already bootstrapped.
+- If bootstrap is missing or outdated, it verifies Python/pip availability, installs `markitdown[<extras>]` via pip, writes skill assets, and refreshes the stamp file.
+- The middleware appends a system prompt that tells the agent to:
+  - use `markitdown` for file-to-Markdown conversion
+  - read the sandbox skill file before first use
+  - redirect output to a file with `>` for saving results
+  - inspect output carefully and summarize results
+- When the agent calls `sandbox_shell` with a `markitdown` command, the middleware ensures bootstrap has completed before the command runs.
+- Non-MarkItDown `sandbox_shell` commands are passed through unchanged.
+
+## Validation Rules
+
+The plugin contributes draft validation warnings in Xpert when:
+
+- the agent uses `MarkItDownSkill` but sandbox support is disabled
+- the agent uses `MarkItDownSkill` without `SandboxShell` on the same agent
+
+## Sandbox Assets
+
+During bootstrap, the plugin writes the following assets into the sandbox:
+
+- `SKILL.md` — comprehensive command reference with quick start, CLI usage, batch patterns, and advanced features
+- `references/supported-formats.md` — detailed per-format conversion guidance
+- a bootstrap stamp file used to avoid unnecessary reinstallation
+
+## Configuration Precedence
+
+Configuration is resolved in this order, from lowest to highest priority:
+
+1. Built-in defaults
+2. Environment variables:
+   - `MARKITDOWN_VERSION`
+   - `MARKITDOWN_SKILLS_DIR`
+   - `MARKITDOWN_EXTRAS`
+3. Plugin-level config resolved by the host plugin config resolver
+4. Middleware `options`
+
+## Advanced Features
+
+### LLM-based Image Description
+
+If `OPENAI_API_KEY` is set in the sandbox environment, MarkItDown can use an LLM to generate descriptions for images embedded in documents:
+
+```bash
+export OPENAI_API_KEY="your-key"
+markitdown photo.jpg
+```
+
+### Azure Document Intelligence
+
+For enhanced PDF/image processing with Azure Document Intelligence:
+
+```bash
+export AZURE_DOCUMENT_INTELLIGENCE_ENDPOINT="https://your-endpoint.cognitiveservices.azure.com/"
+export AZURE_DOCUMENT_INTELLIGENCE_KEY="your-key"
+markitdown --use-docintel complex-document.pdf
+```
+
+To use this feature, set `extras` to `"az-doc-intel"` or `"all"` in the middleware configuration.
+
+## Development & Testing
+
+```bash
+pnpm nx build @xpert-ai/plugin-markitdown
+pnpm nx test @xpert-ai/plugin-markitdown
+```
+
+TypeScript output is emitted to `middlewares/markitdown/dist`.
+
+## License
+
+This project follows the [AGPL-3.0 License](../../../LICENSE) located at the repository root.

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { XpertPlugin } from '@xpert-ai/plugin-sdk';
+declare const plugin: XpertPlugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAWvD,QAAA,MAAM,MAAM,EAAE,WAyBb,CAAA;AAED,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -0,0 +1,34 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { MarkItDownPluginModule } from './lib/markitdown.module.js';
+import { MarkItDownIcon } from './lib/types.js';
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(moduleDir, '../package.json'), 'utf8'));
+const plugin = {
+    meta: {
+        name: packageJson.name,
+        version: packageJson.version,
+        level: 'organization',
+        category: 'middleware',
+        icon: {
+            type: 'svg',
+            value: MarkItDownIcon
+        },
+        displayName: 'MarkItDown',
+        description: 'Installs Microsoft MarkItDown in the sandbox and provides skills for converting files (PDF, DOCX, PPTX, images, audio, etc.) to Markdown.',
+        keywords: ['markitdown', 'markdown', 'pdf', 'docx', 'conversion', 'document'],
+        author: 'XpertAI Team'
+    },
+    register(ctx) {
+        ctx.logger.log('register markitdown plugin');
+        return { module: MarkItDownPluginModule, global: true };
+    },
+    async onStart(ctx) {
+        ctx.logger.log('markitdown plugin started');
+    },
+    async onStop(ctx) {
+        ctx.logger.log('markitdown plugin stopped');
+    }
+};
+export default plugin;

package/dist/lib/markitdown-bootstrap.service.d.ts

@@ -0,0 +1,25 @@
+import { BaseSandbox, type IPluginConfigResolver } from '@xpert-ai/plugin-sdk';
+import { MarkItDownConfig } from './markitdown.types.js';
+type MarkItDownBootstrapBackend = Pick<BaseSandbox, 'execute' | 'uploadFiles'>;
+export declare class MarkItDownBootstrapService {
+    private readonly pluginConfigResolver?;
+    constructor(pluginConfigResolver?: IPluginConfigResolver);
+    resolveConfig(config?: Partial<MarkItDownConfig>): MarkItDownConfig;
+    getStampPath(): string;
+    buildSystemPrompt(config?: {
+        version?: string;
+        skillsDir?: string;
+        extras?: string;
+    }): string;
+    isMarkItDownCommand(command: string): boolean;
+    ensureBootstrap(backend: MarkItDownBootstrapBackend, config?: {
+        version?: string;
+        skillsDir?: string;
+        extras?: string;
+    }): Promise<import("@xpert-ai/plugin-sdk").ExecuteResponse>;
+    private getBootstrapAssets;
+    private writeStamp;
+    private writeAssets;
+}
+export {};
+//# sourceMappingURL=markitdown-bootstrap.service.d.ts.map

package/dist/lib/markitdown-bootstrap.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markitdown-bootstrap.service.d.ts","sourceRoot":"","sources":["../../src/lib/markitdown-bootstrap.service.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,WAAW,EACX,KAAK,qBAAqB,EAE3B,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAKL,gBAAgB,EAEjB,MAAM,uBAAuB,CAAA;AAI9B,KAAK,0BAA0B,GAAG,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,aAAa,CAAC,CAAA;AAQ9E,qBACa,0BAA0B;IAInC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC;gBAArB,oBAAoB,CAAC,EAAE,qBAAqB;IAG/D,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,gBAAgB;IAmBnE,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,MAAM;;;;KAAuB,GAAG,MAAM;IAwBxD,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAOvC,eAAe,CAAC,OAAO,EAAE,0BAA0B,EAAE,MAAM;;;;KAAuB;IA2DxF,OAAO,CAAC,kBAAkB;YAIZ,UAAU;YAaV,WAAW;CA4B1B"}

package/dist/lib/markitdown-bootstrap.service.js

@@ -0,0 +1,150 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Buffer } from 'node:buffer';
+import { posix as path } from 'node:path';
+import { PLUGIN_CONFIG_RESOLVER_TOKEN } from '@xpert-ai/plugin-sdk';
+import { Inject, Injectable, Optional } from '@nestjs/common';
+import { DEFAULT_MARKITDOWN_VERSION, DEFAULT_MARKITDOWN_SKILLS_DIR, DEFAULT_MARKITDOWN_STAMP_PATH, MARKITDOWN_BOOTSTRAP_SCHEMA_VERSION, MarkItDownConfigSchema } from './markitdown.types.js';
+import { MarkItDownPluginName } from './types.js';
+import { getSkillAssets } from './skills/index.js';
+let MarkItDownBootstrapService = class MarkItDownBootstrapService {
+    constructor(pluginConfigResolver) {
+        this.pluginConfigResolver = pluginConfigResolver;
+    }
+    resolveConfig(config) {
+        const defaults = {
+            version: process.env['MARKITDOWN_VERSION'] || DEFAULT_MARKITDOWN_VERSION,
+            skillsDir: process.env['MARKITDOWN_SKILLS_DIR'] || DEFAULT_MARKITDOWN_SKILLS_DIR,
+            extras: process.env['MARKITDOWN_EXTRAS'] || 'all'
+        };
+        const pluginConfig = this.pluginConfigResolver?.resolve(MarkItDownPluginName, {
+            defaults
+        }) ?? defaults;
+        const middlewareConfig = MarkItDownConfigSchema.partial().parse(config ?? {});
+        return MarkItDownConfigSchema.parse({
+            ...defaults,
+            ...pluginConfig,
+            ...middlewareConfig
+        });
+    }
+    getStampPath() {
+        return DEFAULT_MARKITDOWN_STAMP_PATH;
+    }
+    buildSystemPrompt(config = this.resolveConfig()) {
+        return [
+            'The `markitdown` command (from Microsoft markitdown) is installed in the sandbox via pip.',
+            'IMPORTANT: Use the `markitdown` command to convert files to Markdown. It supports PDF, DOCX, PPTX, XLSX, HTML, CSV, JSON, XML, ZIP, images (JPEG/PNG with EXIF and OCR), audio (MP3/WAV with speech-to-text), RSS feeds, and more.',
+            'Always run file conversion via the `sandbox_shell` tool using the `markitdown` command.',
+            `Before your first use, read the skill file at \`${config.skillsDir}/SKILL.md\` with \`cat ${config.skillsDir}/SKILL.md\` to learn all available options and usage patterns.`,
+            '',
+            'QUICK USAGE:',
+            '- Convert a file: `markitdown path/to/file.pdf`',
+            '- Convert a URL: `markitdown https://example.com/page.html`',
+            '- Save output: `markitdown path/to/file.docx > output.md`',
+            '- Piped input: `cat file.html | markitdown`',
+            '',
+            'GUIDELINES:',
+            '- Output goes to stdout by default. Redirect with `>` to save to a file.',
+            '- For large files, the conversion may take a moment. The default timeout should be sufficient for most files.',
+            '- For images, markitdown extracts EXIF metadata and can do OCR if configured.',
+            '- For audio files, markitdown performs speech-to-text transcription.',
+            '- Inspect the output carefully and summarize results back to the user.',
+            '',
+            `For detailed format-specific guidance, read \`${config.skillsDir}/references/supported-formats.md\`.`
+        ].join('\n');
+    }
+    isMarkItDownCommand(command) {
+        if (!command) {
+            return false;
+        }
+        return /\bmarkitdown\b/.test(command);
+    }
+    async ensureBootstrap(backend, config = this.resolveConfig()) {
+        if (!backend || typeof backend.execute !== 'function') {
+            throw new Error('Sandbox backend is not available for MarkItDown bootstrap.');
+        }
+        const stampPath = this.getStampPath();
+        const bootstrapAssets = this.getBootstrapAssets(config);
+        // Check stamp to see if already bootstrapped with same version
+        const stampCheck = await backend.execute(`cat ${shellQuote(stampPath)} 2>/dev/null || echo ''`);
+        const stampContent = stampCheck?.output?.trim() ?? '';
+        if (stampContent) {
+            try {
+                const stamp = JSON.parse(stampContent);
+                if (stamp.version === config.version) {
+                    // Stamp matches, but verify the markitdown binary actually exists
+                    const whichResult = await backend.execute('which markitdown 2>/dev/null');
+                    if (whichResult?.exitCode === 0 && whichResult?.output?.trim()) {
+                        if (stamp.bootstrapVersion !== MARKITDOWN_BOOTSTRAP_SCHEMA_VERSION) {
+                            await this.writeAssets(backend, bootstrapAssets);
+                            await this.writeStamp(backend, config.version);
+                        }
+                        return { output: 'already bootstrapped', exitCode: 0, truncated: false };
+                    }
+                }
+            }
+            catch {
+                // stamp is corrupted, re-bootstrap
+            }
+        }
+        // 1. Check Python/pip availability
+        const pipCheck = await backend.execute('which pip3 2>/dev/null || which pip 2>/dev/null');
+        if (pipCheck?.exitCode !== 0 || !pipCheck?.output?.trim()) {
+            throw new Error('Python pip is not available in the sandbox. MarkItDown requires Python with pip to be pre-installed.');
+        }
+        const pipCmd = pipCheck.output.trim().split('\n')[0];
+        // 2. Install markitdown via pip
+        const versionSpec = config.version === 'latest' ? '' : `==${config.version}`;
+        const extrasSpec = config.extras ? `[${config.extras}]` : '';
+        const installCmd = `${pipCmd} install "markitdown${extrasSpec}${versionSpec}"`;
+        const installResult = await backend.execute(installCmd);
+        if (installResult?.exitCode !== 0) {
+            throw new Error(`MarkItDown install failed: ${installResult?.output || 'Unknown error'}`);
+        }
+        // 3. Upload skill files to sandbox
+        await this.writeAssets(backend, bootstrapAssets);
+        // 4. Write stamp file
+        await this.writeStamp(backend, config.version);
+        return installResult;
+    }
+    getBootstrapAssets(config) {
+        return getSkillAssets(config.skillsDir);
+    }
+    async writeStamp(backend, version) {
+        const stampPath = this.getStampPath();
+        const stampData = JSON.stringify({
+            tool: 'markitdown',
+            version,
+            bootstrapVersion: MARKITDOWN_BOOTSTRAP_SCHEMA_VERSION,
+            installedAt: new Date().toISOString()
+        });
+        await backend.execute(`mkdir -p ${shellQuote(path.dirname(stampPath))} && echo ${shellQuote(stampData)} > ${shellQuote(stampPath)}`);
+    }
+    async writeAssets(backend, assets) {
+        const canUploadDirectly = typeof backend.uploadFiles === 'function' && assets.every((asset) => !path.isAbsolute(asset.path));
+        if (canUploadDirectly) {
+            const results = await backend.uploadFiles(assets.map(({ path, content }) => [path, Buffer.from(content, 'utf8')]));
+            const failed = results?.filter((result) => result.error);
+            if (failed?.length) {
+                throw new Error(`Failed to write MarkItDown skill assets: ${failed.map((item) => item.path).join(', ')}`);
+            }
+            return;
+        }
+        for (const asset of assets) {
+            const dir = path.dirname(asset.path);
+            const result = await backend.execute(`mkdir -p ${shellQuote(dir)} && cat <<'__XPERT_MARKITDOWN_EOF__' > ${shellQuote(asset.path)}\n${asset.content}\n__XPERT_MARKITDOWN_EOF__`);
+            if (result?.exitCode !== 0) {
+                throw new Error(`Failed to write MarkItDown skill asset ${asset.path}: ${result?.output || 'Unknown error'}`);
+            }
+        }
+    }
+};
+MarkItDownBootstrapService = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __param(0, Inject(PLUGIN_CONFIG_RESOLVER_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], MarkItDownBootstrapService);
+export { MarkItDownBootstrapService };
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}

package/dist/lib/markitdown.middleware.d.ts

@@ -0,0 +1,11 @@
+import { TAgentMiddlewareMeta } from '@metad/contracts';
+import { AgentMiddleware, IAgentMiddlewareContext, IAgentMiddlewareStrategy } from '@xpert-ai/plugin-sdk';
+import { MarkItDownBootstrapService } from './markitdown-bootstrap.service.js';
+import { MarkItDownConfig } from './markitdown.types.js';
+export declare class MarkItDownSkillMiddleware implements IAgentMiddlewareStrategy<Partial<MarkItDownConfig>> {
+    private readonly markitdownBootstrapService;
+    constructor(markitdownBootstrapService: MarkItDownBootstrapService);
+    meta: TAgentMiddlewareMeta;
+    createMiddleware(options: Partial<MarkItDownConfig>, _context: IAgentMiddlewareContext): AgentMiddleware;
+}
+//# sourceMappingURL=markitdown.middleware.d.ts.map

package/dist/lib/markitdown.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markitdown.middleware.d.ts","sourceRoot":"","sources":["../../src/lib/markitdown.middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvD,OAAO,EACL,eAAe,EAIf,uBAAuB,EACvB,wBAAwB,EAGzB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAA;AAC9E,OAAO,EAEL,gBAAgB,EAEjB,MAAM,uBAAuB,CAAA;AAK9B,qBAEa,yBAA0B,YAAW,wBAAwB,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACvF,OAAO,CAAC,QAAQ,CAAC,0BAA0B;gBAA1B,0BAA0B,EAAE,0BAA0B;IAEnF,IAAI,EAAE,oBAAoB,CAezB;IAED,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAAE,QAAQ,EAAE,uBAAuB,GAAG,eAAe;CAkDzG"}

package/dist/lib/markitdown.middleware.js

@@ -0,0 +1,94 @@
+import { __decorate, __metadata } from "tslib";
+import { SystemMessage } from '@langchain/core/messages';
+import { Injectable } from '@nestjs/common';
+import { AgentMiddlewareStrategy } from '@xpert-ai/plugin-sdk';
+import { MarkItDownBootstrapService } from './markitdown-bootstrap.service.js';
+import { MARKITDOWN_SKILL_MIDDLEWARE_NAME, MarkItDownConfigFormSchema } from './markitdown.types.js';
+import { MarkItDownIcon } from './types.js';
+const SANDBOX_SHELL_TOOL_NAME = 'sandbox_shell';
+let MarkItDownSkillMiddleware = class MarkItDownSkillMiddleware {
+    constructor(markitdownBootstrapService) {
+        this.markitdownBootstrapService = markitdownBootstrapService;
+        this.meta = {
+            name: MARKITDOWN_SKILL_MIDDLEWARE_NAME,
+            label: {
+                en_US: 'MarkItDown Skill',
+                zh_Hans: 'MarkItDown 技能'
+            },
+            description: {
+                en_US: 'Installs Microsoft MarkItDown into the sandbox and teaches the agent to convert files (PDF, DOCX, PPTX, images, audio, etc.) to Markdown via sandbox_shell.',
+                zh_Hans: '将 Microsoft MarkItDown 安装到 sandbox 中，并教会智能体通过 sandbox_shell 将文件（PDF、DOCX、PPTX、图片、音频等）转换为 Markdown。'
+            },
+            icon: {
+                type: 'svg',
+                value: MarkItDownIcon
+            },
+            configSchema: MarkItDownConfigFormSchema
+        };
+    }
+    createMiddleware(options, _context) {
+        const config = this.markitdownBootstrapService.resolveConfig(options);
+        return {
+            name: MARKITDOWN_SKILL_MIDDLEWARE_NAME,
+            tools: [],
+            beforeAgent: async (_state, runtime) => {
+                const backend = getSandboxBackend(runtime);
+                await this.markitdownBootstrapService.ensureBootstrap(backend, config);
+            },
+            wrapModelCall: async (request, handler) => {
+                const backend = getSandboxBackend(request.runtime);
+                if (!backend) {
+                    return handler(request);
+                }
+                const prompt = this.markitdownBootstrapService.buildSystemPrompt(config);
+                const baseContent = `${request.systemMessage?.content ?? ''}`.trim();
+                const content = [baseContent, prompt].filter(Boolean).join('\n\n');
+                return handler({
+                    ...request,
+                    systemMessage: new SystemMessage({
+                        content
+                    })
+                });
+            },
+            wrapToolCall: async (request, handler) => {
+                if (!isSandboxShellTool(request.tool)) {
+                    return handler(request);
+                }
+                const command = getSandboxShellCommand(request);
+                if (!this.markitdownBootstrapService.isMarkItDownCommand(command)) {
+                    return handler(request);
+                }
+                // Ensure markitdown is installed before running the command
+                const backend = getSandboxBackend(request.runtime);
+                if (backend) {
+                    await this.markitdownBootstrapService.ensureBootstrap(backend, config);
+                }
+                return handler(request);
+            }
+        };
+    }
+};
+MarkItDownSkillMiddleware = __decorate([
+    Injectable(),
+    AgentMiddlewareStrategy(MARKITDOWN_SKILL_MIDDLEWARE_NAME),
+    __metadata("design:paramtypes", [MarkItDownBootstrapService])
+], MarkItDownSkillMiddleware);
+export { MarkItDownSkillMiddleware };
+function getSandboxBackend(runtime) {
+    const backend = runtime?.configurable?.sandbox?.backend;
+    if (backend && typeof backend.execute === 'function') {
+        return backend;
+    }
+    return null;
+}
+function isSandboxShellTool(tool) {
+    return tool?.name === SANDBOX_SHELL_TOOL_NAME;
+}
+function getSandboxShellCommand(request) {
+    const args = request.toolCall?.args;
+    if (!args || typeof args !== 'object') {
+        return '';
+    }
+    const command = args['command'];
+    return typeof command === 'string' ? command : '';
+}

package/dist/lib/markitdown.module.d.ts

@@ -0,0 +1,7 @@
+import { IOnPluginBootstrap, IOnPluginDestroy } from '@xpert-ai/plugin-sdk';
+export declare class MarkItDownPluginModule implements IOnPluginBootstrap, IOnPluginDestroy {
+    private logEnabled;
+    onPluginBootstrap(): void | Promise<void>;
+    onPluginDestroy(): void | Promise<void>;
+}
+//# sourceMappingURL=markitdown.module.d.ts.map

package/dist/lib/markitdown.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markitdown.module.d.ts","sourceRoot":"","sources":["../../src/lib/markitdown.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAM9F,qBAQa,sBAAuB,YAAW,kBAAkB,EAAE,gBAAgB;IACjF,OAAO,CAAC,UAAU,CAAO;IAEzB,iBAAiB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC,eAAe,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAKxC"}

package/dist/lib/markitdown.module.js

@@ -0,0 +1,33 @@
+var MarkItDownPluginModule_1;
+import { __decorate } from "tslib";
+import { XpertServerPlugin } from '@xpert-ai/plugin-sdk';
+import chalk from 'chalk';
+import { MarkItDownBootstrapService } from './markitdown-bootstrap.service.js';
+import { MarkItDownSkillMiddleware } from './markitdown.middleware.js';
+import { MarkItDownSkillValidator } from './markitdown.validator.js';
+let MarkItDownPluginModule = MarkItDownPluginModule_1 = class MarkItDownPluginModule {
+    constructor() {
+        this.logEnabled = true;
+    }
+    onPluginBootstrap() {
+        if (this.logEnabled) {
+            console.log(chalk.green(`${MarkItDownPluginModule_1.name} is being bootstrapped...`));
+        }
+    }
+    onPluginDestroy() {
+        if (this.logEnabled) {
+            console.log(chalk.green(`${MarkItDownPluginModule_1.name} is being destroyed...`));
+        }
+    }
+};
+MarkItDownPluginModule = MarkItDownPluginModule_1 = __decorate([
+    XpertServerPlugin({
+        imports: [],
+        providers: [
+            MarkItDownBootstrapService,
+            MarkItDownSkillMiddleware,
+            MarkItDownSkillValidator
+        ]
+    })
+], MarkItDownPluginModule);
+export { MarkItDownPluginModule };

package/dist/lib/markitdown.types.d.ts

@@ -0,0 +1,23 @@
+import { JsonSchemaObjectType } from '@metad/contracts';
+import { z } from 'zod';
+export declare const MARKITDOWN_SKILL_MIDDLEWARE_NAME = "MarkItDownSkill";
+export declare const DEFAULT_MARKITDOWN_VERSION = "latest";
+export declare const DEFAULT_MARKITDOWN_SKILLS_DIR = "/workspace/.xpert/skills/markitdown";
+export declare const DEFAULT_MARKITDOWN_STAMP_PATH = "/workspace/.xpert/.markitdown-bootstrap.json";
+export declare const MARKITDOWN_BOOTSTRAP_SCHEMA_VERSION = 1;
+export declare const MarkItDownConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    skillsDir: z.ZodDefault<z.ZodString>;
+    extras: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    skillsDir?: string;
+    extras?: string;
+}, {
+    version?: string;
+    skillsDir?: string;
+    extras?: string;
+}>;
+export type MarkItDownConfig = z.infer<typeof MarkItDownConfigSchema>;
+export declare const MarkItDownConfigFormSchema: JsonSchemaObjectType;
+//# sourceMappingURL=markitdown.types.d.ts.map

package/dist/lib/markitdown.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markitdown.types.d.ts","sourceRoot":"","sources":["../../src/lib/markitdown.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gCAAgC,oBAAoB,CAAA;AACjE,eAAO,MAAM,0BAA0B,WAAW,CAAA;AAClD,eAAO,MAAM,6BAA6B,wCAAwC,CAAA;AAClF,eAAO,MAAM,6BAA6B,iDAAiD,CAAA;AAC3F,eAAO,MAAM,mCAAmC,IAAI,CAAA;AAEpD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EAIjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,0BAA0B,EAAE,oBA2CxC,CAAA"}

package/dist/lib/markitdown.types.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export const MARKITDOWN_SKILL_MIDDLEWARE_NAME = 'MarkItDownSkill';
+export const DEFAULT_MARKITDOWN_VERSION = 'latest';
+export const DEFAULT_MARKITDOWN_SKILLS_DIR = '/workspace/.xpert/skills/markitdown';
+export const DEFAULT_MARKITDOWN_STAMP_PATH = '/workspace/.xpert/.markitdown-bootstrap.json';
+export const MARKITDOWN_BOOTSTRAP_SCHEMA_VERSION = 1;
+export const MarkItDownConfigSchema = z.object({
+    version: z.string().min(1).default(DEFAULT_MARKITDOWN_VERSION),
+    skillsDir: z.string().min(1).default(DEFAULT_MARKITDOWN_SKILLS_DIR),
+    extras: z.string().min(1).default('all')
+});
+export const MarkItDownConfigFormSchema = {
+    type: 'object',
+    properties: {
+        version: {
+            type: 'string',
+            title: {
+                en_US: 'MarkItDown Version',
+                zh_Hans: 'MarkItDown 版本'
+            },
+            description: {
+                en_US: 'The markitdown version to install via pip in the sandbox (e.g. "latest" or "0.1.1").',
+                zh_Hans: '在 sandbox 中通过 pip 安装的 markitdown 版本（如 "latest" 或 "0.1.1"）。'
+            },
+            default: DEFAULT_MARKITDOWN_VERSION
+        },
+        extras: {
+            type: 'string',
+            title: {
+                en_US: 'Pip Extras',
+                zh_Hans: 'Pip Extras'
+            },
+            description: {
+                en_US: 'Python extras to install (e.g. "all", "ocr", "az-doc-intel"). Use "all" for full functionality.',
+                zh_Hans: '要安装的 Python extras（如 "all"、"ocr"、"az-doc-intel"）。使用 "all" 获得完整功能。'
+            },
+            default: 'all'
+        },
+        skillsDir: {
+            type: 'string',
+            title: {
+                en_US: 'Skills Directory',
+                zh_Hans: 'Skills 目录'
+            },
+            description: {
+                en_US: 'Path inside the sandbox where skill files (SKILL.md and references) are written.',
+                zh_Hans: 'sandbox 中写入 skill 文件（SKILL.md 和 references）的目录路径。'
+            },
+            default: DEFAULT_MARKITDOWN_SKILLS_DIR,
+            'x-ui': {
+                span: 2
+            }
+        }
+    }
+};

package/dist/lib/markitdown.validator.d.ts

@@ -0,0 +1,9 @@
+import { ChecklistItem, TXpertTeamDraft } from '@metad/contracts';
+type XpertDraftValidateEvent = {
+    draft: TXpertTeamDraft;
+};
+export declare class MarkItDownSkillValidator {
+    handle(event: XpertDraftValidateEvent): ChecklistItem[];
+}
+export {};
+//# sourceMappingURL=markitdown.validator.d.ts.map

package/dist/lib/markitdown.validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markitdown.validator.d.ts","sourceRoot":"","sources":["../../src/lib/markitdown.validator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAGb,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAQzB,KAAK,uBAAuB,GAAG;IAC7B,KAAK,EAAE,eAAe,CAAA;CACvB,CAAA;AAED,qBACa,wBAAwB;IAEnC,MAAM,CAAC,KAAK,EAAE,uBAAuB;CAmDtC"}

package/dist/lib/markitdown.validator.js

@@ -0,0 +1,64 @@
+import { __decorate, __metadata } from "tslib";
+import { getAgentMiddlewareNodes } from '@metad/contracts';
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { MARKITDOWN_SKILL_MIDDLEWARE_NAME } from './markitdown.types.js';
+const SANDBOX_SHELL_MIDDLEWARE_NAME = 'SandboxShell';
+const EventNameXpertValidate = 'xpert.validate';
+let MarkItDownSkillValidator = class MarkItDownSkillValidator {
+    handle(event) {
+        const draft = event.draft;
+        const sandboxEnabled = !!draft.team?.features?.sandbox?.enabled;
+        const agentNodes = draft.nodes.filter((node) => node.type === 'agent');
+        const items = [];
+        agentNodes.forEach((agentNode) => {
+            const middlewares = getAgentMiddlewareNodes(draft, agentNode.key).map((node) => node);
+            const middlewareEntities = middlewares.map((node) => ({
+                node,
+                entity: node.entity
+            }));
+            const hasSandboxShell = middlewareEntities.some(({ entity }) => entity.provider === SANDBOX_SHELL_MIDDLEWARE_NAME);
+            middlewareEntities
+                .filter(({ entity }) => entity.provider === MARKITDOWN_SKILL_MIDDLEWARE_NAME)
+                .forEach(({ node, entity }) => {
+                if (!sandboxEnabled) {
+                    items.push({
+                        node: node.key,
+                        ruleCode: 'MARKITDOWN_SKILL_SANDBOX_DISABLED',
+                        field: 'provider',
+                        value: entity.provider,
+                        level: 'warning',
+                        message: {
+                            en_US: 'MarkItDownSkill requires the agent sandbox feature to be enabled.',
+                            zh_Hans: 'MarkItDownSkill 需要先启用智能体的 sandbox 功能。'
+                        }
+                    });
+                }
+                if (!hasSandboxShell) {
+                    items.push({
+                        node: node.key,
+                        ruleCode: 'MARKITDOWN_SKILL_SANDBOX_SHELL_MISSING',
+                        field: 'provider',
+                        value: entity.provider,
+                        level: 'warning',
+                        message: {
+                            en_US: 'MarkItDownSkill should be paired with the SandboxShell middleware on the same agent.',
+                            zh_Hans: 'MarkItDownSkill 需要与同一智能体上的 SandboxShell 中间件配合使用。'
+                        }
+                    });
+                }
+            });
+        });
+        return items;
+    }
+};
+__decorate([
+    OnEvent(EventNameXpertValidate),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], MarkItDownSkillValidator.prototype, "handle", null);
+MarkItDownSkillValidator = __decorate([
+    Injectable()
+], MarkItDownSkillValidator);
+export { MarkItDownSkillValidator };

package/dist/lib/skills/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: markitdown
+description: Converts files and URLs to Markdown. Use when the user needs to extract text from PDF, DOCX, PPTX, XLSX, HTML, images, audio, or other documents and convert them to clean Markdown format.
+allowed-tools: Bash(markitdown:*)
+---
+
+# File-to-Markdown Conversion with markitdown
+
+## Quick start
+
+```bash
+# Convert a local file to Markdown (output to stdout)
+markitdown document.pdf
+
+# Save output to a file
+markitdown document.pdf > document.md
+
+# Convert from a URL
+markitdown https://example.com/page.html
+
+# Pipe input
+cat report.docx | markitdown
+
+# Convert with explicit output flag
+markitdown document.pptx -o output.md
+```
+
+## Supported File Formats
+
+| Format | Extensions | Notes |
+|--------|-----------|-------|
+| PDF | `.pdf` | Text extraction, layout preservation |
+| Word | `.docx` | Full document structure, tables, images |
+| PowerPoint | `.pptx` | Slides, speaker notes, embedded content |
+| Excel | `.xlsx` | Sheets as Markdown tables |
+| HTML | `.html`, `.htm` | Web page content extraction |
+| CSV | `.csv` | Converted to Markdown tables |
+| JSON | `.json` | Structured representation |
+| XML | `.xml` | Structured representation |
+| Plain Text | `.txt`, `.md`, `.rst` | Pass-through with minimal processing |
+| Images | `.jpg`, `.jpeg`, `.png` | EXIF metadata extraction, OCR if available |
+| Audio | `.mp3`, `.wav` | Speech-to-text transcription |
+| ZIP | `.zip` | Recursively converts contained files |
+| RSS/Atom | `.xml` (feeds) | Feed entry extraction |
+| EPUB | `.epub` | Book content extraction |
+
+## CLI Usage
+
+### Basic conversion
+
+```bash
+# Convert any supported file
+markitdown <input-file>
+
+# Convert from URL
+markitdown <url>
+```
+
+### Output options
+
+```bash
+# Redirect to file
+markitdown input.pdf > output.md
+
+# Use -o flag
+markitdown input.pdf -o output.md
+```
+
+### Piped input
+
+```bash
+# Pipe from another command
+cat document.html | markitdown
+curl -s https://example.com | markitdown
+```
+
+### Batch conversion
+
+```bash
+# Convert all PDFs in a directory
+for f in *.pdf; do markitdown "$f" > "${f%.pdf}.md"; done
+
+# Convert multiple specific files
+for f in report.docx slides.pptx data.xlsx; do
+  markitdown "$f" > "${f%.*}.md"
+done
+```
+
+## Advanced Features
+
+### Image description with LLM
+
+If `OPENAI_API_KEY` is set in the environment, markitdown can use an LLM to generate descriptions for images:
+
+```bash
+export OPENAI_API_KEY="your-key"
+markitdown photo.jpg
+```
+
+### Document Intelligence (Azure)
+
+For enhanced PDF/image processing with Azure Document Intelligence:
+
+```bash
+export AZURE_DOCUMENT_INTELLIGENCE_ENDPOINT="https://your-endpoint.cognitiveservices.azure.com/"
+export AZURE_DOCUMENT_INTELLIGENCE_KEY="your-key"
+markitdown --use-docintel complex-document.pdf
+```
+
+## Tips
+
+- **Large files**: For very large documents, conversion may take longer. Be patient and let it complete.
+- **Tables**: Excel files and HTML tables are converted to proper Markdown table syntax.
+- **Images in documents**: Images embedded in DOCX/PPTX are described if LLM support is configured.
+- **Error handling**: If a file format is not supported, markitdown will output an informative error message.
+- **Chaining**: Combine markitdown output with other tools for further processing:
+  ```bash
+  markitdown report.pdf | grep "revenue"
+  markitdown data.xlsx | head -50
+  ```

package/dist/lib/skills/index.d.ts

@@ -0,0 +1,13 @@
+export type MarkItDownSkillAsset = {
+    path: string;
+    content: string;
+};
+/**
+ * Returns all markitdown skill files as assets ready to be uploaded
+ * into the sandbox container.
+ *
+ * @param skillsDir - The target directory inside the sandbox where
+ *   skill files will be written, e.g. `/workspace/.xpert/skills/markitdown`.
+ */
+export declare function getSkillAssets(skillsDir: string): MarkItDownSkillAsset[];
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/skills/index.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAWD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAKxE"}

package/dist/lib/skills/index.js

@@ -0,0 +1,25 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { posix as path } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+function readSkill(relativePath) {
+    return readFileSync(join(moduleDir, relativePath), 'utf8');
+}
+const SKILL_FILES = [
+    { name: 'SKILL.md', src: 'SKILL.md' },
+    { name: 'references/supported-formats.md', src: 'references/supported-formats.md' }
+];
+/**
+ * Returns all markitdown skill files as assets ready to be uploaded
+ * into the sandbox container.
+ *
+ * @param skillsDir - The target directory inside the sandbox where
+ *   skill files will be written, e.g. `/workspace/.xpert/skills/markitdown`.
+ */
+export function getSkillAssets(skillsDir) {
+    return SKILL_FILES.map(({ name, src }) => ({
+        path: path.join(skillsDir, name),
+        content: readSkill(src)
+    }));
+}

package/dist/lib/skills/references/supported-formats.md

@@ -0,0 +1,149 @@
+# Supported Formats — Detailed Guide
+
+## PDF (.pdf)
+
+MarkItDown extracts text from PDF files while preserving the document structure.
+
+```bash
+markitdown report.pdf
+markitdown report.pdf > report.md
+```
+
+**Notes:**
+- Scanned PDFs (image-based) require OCR support. Install with `markitdown[ocr]` extras or use Azure Document Intelligence with `--use-docintel`.
+- Multi-column layouts are processed left-to-right, top-to-bottom.
+- Tables in PDFs are extracted as Markdown tables when possible.
+- Headers and footers are typically included in the output.
+
+---
+
+## Word Documents (.docx)
+
+Full support for Microsoft Word documents including:
+- Headings (H1–H6 mapping)
+- Paragraphs with formatting (bold, italic)
+- Tables (converted to Markdown tables)
+- Bulleted and numbered lists
+- Embedded images (described with LLM if `OPENAI_API_KEY` is set)
+- Hyperlinks
+
+```bash
+markitdown contract.docx
+```
+
+---
+
+## PowerPoint (.pptx)
+
+Converts presentations to Markdown with one section per slide:
+- Slide titles become headings
+- Bullet points preserved as lists
+- Speaker notes included (when present)
+- Embedded images described (with LLM support)
+- Tables converted to Markdown tables
+
+```bash
+markitdown presentation.pptx
+```
+
+---
+
+## Excel (.xlsx)
+
+Each worksheet is converted to a Markdown table:
+- Sheet names become section headings
+- Cell values preserved
+- Formulas are evaluated (showing results, not formulas)
+- Multiple sheets are separated by headings
+
+```bash
+markitdown financials.xlsx
+```
+
+---
+
+## HTML (.html, .htm)
+
+Converts web pages to clean Markdown:
+- Strips scripts, styles, and navigation elements
+- Preserves semantic structure (headings, lists, tables, links)
+- Inline images referenced
+
+```bash
+markitdown page.html
+markitdown https://example.com/article
+```
+
+---
+
+## CSV (.csv)
+
+Converts CSV data directly to Markdown tables:
+- First row treated as table header
+- All subsequent rows as table body
+
+```bash
+markitdown data.csv
+```
+
+---
+
+## Images (.jpg, .jpeg, .png)
+
+For images, markitdown can:
+1. **Extract EXIF metadata** (camera model, date, GPS coordinates, etc.)
+2. **OCR** (when `markitdown[ocr]` extras are installed)
+3. **LLM description** (when `OPENAI_API_KEY` is set)
+
+```bash
+markitdown photo.jpg
+```
+
+---
+
+## Audio (.mp3, .wav)
+
+Speech-to-text transcription using available backends:
+- Produces a Markdown document with the transcribed text
+- Requires audio processing dependencies (`markitdown[all]`)
+
+```bash
+markitdown recording.mp3
+```
+
+---
+
+## ZIP Archives (.zip)
+
+Recursively extracts and converts all supported files within the archive:
+- Each file gets its own section
+- Nested directories are preserved in the heading structure
+
+```bash
+markitdown documents.zip
+```
+
+---
+
+## RSS/Atom Feeds
+
+Extracts feed entries as a structured Markdown document:
+- Feed title as main heading
+- Each entry with title, date, summary/content
+
+```bash
+markitdown https://example.com/feed.xml
+```
+
+---
+
+## EPUB (.epub)
+
+Converts e-book content to Markdown:
+- Chapters become sections
+- Rich formatting preserved
+- Images referenced
+
+```bash
+markitdown book.epub
+```

package/dist/lib/types.d.ts

@@ -0,0 +1,3 @@
+export declare const MarkItDownPluginName = "markitdown";
+export declare const MarkItDownIcon = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<svg version=\"1.1\" id=\"Layer_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\n\t viewBox=\"0 0 129 129\" style=\"enable-background:new 0 0 129 129;\" xml:space=\"preserve\">\n<style type=\"text/css\">\n\t.st0{fill:#F25022;}\n\t.st1{fill:#7FBA00;}\n\t.st2{fill:#00A4EF;}\n\t.st3{fill:#FFB900;}\n</style>\n<path class=\"st0\" d=\"M0,0h61.3v61.3H0V0z\"/>\n<path class=\"st1\" d=\"M67.7,0H129v61.3H67.7V0z\"/>\n<path class=\"st2\" d=\"M0,67.7h61.3V129H0V67.7z\"/>\n<path class=\"st3\" d=\"M67.7,67.7H129V129H67.7V67.7z\"/>\n</svg>";
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,eAAe,CAAA;AAGhD,eAAO,MAAM,cAAc,4nBAapB,CAAA"}

package/dist/lib/types.js

@@ -0,0 +1,16 @@
+export const MarkItDownPluginName = 'markitdown';
+// MarkItDown SVG icon (document-to-markdown conversion)
+export const MarkItDownIcon = `<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 129 129" style="enable-background:new 0 0 129 129;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#F25022;}
+	.st1{fill:#7FBA00;}
+	.st2{fill:#00A4EF;}
+	.st3{fill:#FFB900;}
+</style>
+<path class="st0" d="M0,0h61.3v61.3H0V0z"/>
+<path class="st1" d="M67.7,0H129v61.3H67.7V0z"/>
+<path class="st2" d="M0,67.7h61.3V129H0V67.7z"/>
+<path class="st3" d="M67.7,67.7H129V129H67.7V67.7z"/>
+</svg>`;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@xpert-ai/plugin-markitdown",
+  "version": "0.0.1",
+  "author": {
+    "name": "XpertAI",
+    "url": "https://xpertai.cn"
+  },
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xpert-ai/xpert-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xpert-ai/xpert-plugins/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@xpert-plugins-starter/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@metad/contracts": "^3.8.3",
+    "@xpert-ai/plugin-sdk": "^3.8.3"
+  },
+  "scripts": {}
+}