@aopslabs/aops 0.2.0

package/dist/launchers/cockpit.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { startCommunityNativeCockpit } from '../lib/community-cockpit-lifecycle.js';
+import { communityTerminalLauncherHelp, isCommunityTerminalDirectExecution, parseCommunityTerminalLauncherOptions, } from './options.js';
+const defaultRuntime = Object.freeze({
+    startCockpit: (options) => startCommunityNativeCockpit(options),
+    stdout: process.stdout,
+});
+export async function runCommunityCockpitTerminal(argv, runtime = defaultRuntime) {
+    const options = parseCommunityTerminalLauncherOptions(argv);
+    if (options.help) {
+        runtime.stdout.write(communityTerminalLauncherHelp('cockpit'));
+        return;
+    }
+    const result = await runtime.startCockpit({
+        instanceName: options.instance,
+        dataRoot: options.dataRoot,
+    });
+    runtime.stdout.write(result.action === 'started'
+        ? `AOPS Cockpit started independently at ${result.origin}. API proxy: ${result.serverOrigin}\n`
+        : `AOPS Cockpit is already running at ${result.origin}.\n`);
+}
+if (isCommunityTerminalDirectExecution(import.meta.url)) {
+    void runCommunityCockpitTerminal(process.argv.slice(2)).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`AOPS Cockpit launcher failed: ${message}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/launchers/options.js

@@ -0,0 +1,74 @@
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function isCommunityTerminalDirectExecution(moduleUrl, argvEntry = process.argv[1]) {
+    if (typeof argvEntry !== 'string')
+        return false;
+    try {
+        const entryPath = realpathSync.native(path.resolve(argvEntry));
+        const modulePath = realpathSync.native(fileURLToPath(moduleUrl));
+        return path.relative(entryPath, modulePath) === '' && path.relative(modulePath, entryPath) === '';
+    }
+    catch {
+        return false;
+    }
+}
+function readOptionValue(argv, index, option) {
+    const value = argv[index + 1];
+    if (!value || value.startsWith('-'))
+        throw new Error(`terminal_launcher_option_value_missing:${option}`);
+    return { value, nextIndex: index + 1 };
+}
+export function parseCommunityTerminalLauncherOptions(argv) {
+    let instance;
+    let dataRoot;
+    let help = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument === '--help' || argument === '-h') {
+            help = true;
+            continue;
+        }
+        if (argument === '--instance') {
+            if (instance !== undefined)
+                throw new Error('terminal_launcher_option_duplicate:--instance');
+            const parsed = readOptionValue(argv, index, '--instance');
+            instance = parsed.value;
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (argument.startsWith('--instance=')) {
+            if (instance !== undefined)
+                throw new Error('terminal_launcher_option_duplicate:--instance');
+            instance = argument.slice('--instance='.length);
+            if (!instance)
+                throw new Error('terminal_launcher_option_value_missing:--instance');
+            continue;
+        }
+        if (argument === '--data-root') {
+            if (dataRoot !== undefined)
+                throw new Error('terminal_launcher_option_duplicate:--data-root');
+            const parsed = readOptionValue(argv, index, '--data-root');
+            dataRoot = parsed.value;
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (argument.startsWith('--data-root=')) {
+            if (dataRoot !== undefined)
+                throw new Error('terminal_launcher_option_duplicate:--data-root');
+            dataRoot = argument.slice('--data-root='.length);
+            if (!dataRoot)
+                throw new Error('terminal_launcher_option_value_missing:--data-root');
+            continue;
+        }
+        throw new Error(`terminal_launcher_option_unknown:${argument}`);
+    }
+    return Object.freeze({ instance, dataRoot, help });
+}
+export function communityTerminalLauncherHelp(service) {
+    const executable = service === 'server' ? 'aops-server' : 'aops-cockpit';
+    const purpose = service === 'server'
+        ? 'Run AOPS Server in this terminal with live logs. Ctrl+C stops it.'
+        : 'Start Cockpit independently on its own loopback port.';
+    return `${purpose}\n\nUsage:\n  ${executable} [--instance <name>] [--data-root <absolute-path>]\n`;
+}

package/dist/launchers/server.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { runCommunityServerStart, } from '../commands/community-server.js';
+import { communityTerminalLauncherHelp, isCommunityTerminalDirectExecution, parseCommunityTerminalLauncherOptions, } from './options.js';
+const defaultRuntime = Object.freeze({
+    startServer: (options) => runCommunityServerStart(options),
+    stdout: process.stdout,
+});
+export async function runCommunityServerTerminal(argv, runtime = defaultRuntime) {
+    const options = parseCommunityTerminalLauncherOptions(argv);
+    if (options.help) {
+        runtime.stdout.write(communityTerminalLauncherHelp('server'));
+        return;
+    }
+    runtime.stdout.write('Starting AOPS Server in this terminal. Live server logs follow; press Ctrl+C to stop.\n');
+    await runtime.startServer({
+        instance: options.instance,
+        dataRoot: options.dataRoot,
+        foreground: true,
+        silent: true,
+        resultSink: (result) => {
+            const value = result;
+            const origin = typeof value.origin === 'string' ? ` at ${value.origin}` : '';
+            const pid = typeof value.pid === 'number' ? ` (PID ${value.pid})` : '';
+            runtime.stdout.write(`AOPS Server is running${origin}${pid}.\n`);
+        },
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+if (isCommunityTerminalDirectExecution(import.meta.url)) {
+    void runCommunityServerTerminal(process.argv.slice(2)).catch((error) => {
+        const message = errorMessage(error);
+        if (message === 'community_operation_aborted') {
+            process.stdout.write('AOPS Server stopped.\n');
+            return;
+        }
+        process.stderr.write(`AOPS Server terminal launcher failed: ${message}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/lib/agent-assets/envelope.js

@@ -0,0 +1,83 @@
+export const AGENT_ASSETS_SURFACE = 'agent-assets-client-v1';
+export const AGENT_ASSETS_ERROR_CODES = [
+    'not_found',
+    'ambiguous',
+    'remote_unavailable',
+    'hash_mismatch',
+    'untrusted_origin',
+    'expected_manifest_required',
+    'invalid_package_path',
+    'link_unsafe_path',
+    'binding_conflict',
+    'concurrent_writer',
+    'different_machine_store',
+    'store_identity_mismatch',
+    'publication_conflict',
+    'atomic_replace_blocked',
+    'atomic_primitive_unavailable',
+    'durability_unavailable',
+    'recovery_confirmation_required',
+    'schema_incompatible',
+    'rollback_unavailable',
+];
+export class AgentAssetsError extends Error {
+    code;
+    nextActions;
+    details;
+    constructor(code, message, options) {
+        super(message, { cause: options.cause });
+        this.name = 'AgentAssetsError';
+        this.code = code;
+        this.nextActions = Object.freeze([...options.nextActions]);
+        this.details = options.details === undefined ? undefined : Object.freeze({ ...options.details });
+    }
+}
+export function agentAssetsSuccess(input) {
+    return Object.freeze({
+        schemaVersion: 1,
+        command: input.command,
+        surface: AGENT_ASSETS_SURFACE,
+        ok: true,
+        result: input.result,
+        diagnostics: Object.freeze([...(input.diagnostics ?? [])]),
+        nextActions: Object.freeze([...(input.nextActions ?? [])]),
+    });
+}
+export function agentAssetsFailure(command, error, diagnostics = []) {
+    const normalized = error instanceof AgentAssetsError
+        ? error
+        : new AgentAssetsError('schema_incompatible', error instanceof Error ? error.message : String(error), {
+            nextActions: ['Run `aops assets status --verify quick --json` and inspect the reported diagnostics.'],
+            cause: error,
+        });
+    const commandError = Object.freeze({
+        code: normalized.code,
+        message: normalized.message,
+        nextActions: normalized.nextActions,
+        ...(normalized.details === undefined ? {} : { details: normalized.details }),
+    });
+    return Object.freeze({
+        schemaVersion: 1,
+        command,
+        surface: AGENT_ASSETS_SURFACE,
+        ok: false,
+        error: commandError,
+        diagnostics: Object.freeze([...diagnostics]),
+        nextActions: normalized.nextActions,
+    });
+}
+export function assertBoundedDiscoveryEnvelope(envelope, candidateCount) {
+    if (candidateCount > 5) {
+        throw new AgentAssetsError('schema_incompatible', 'Discovery returned more than five metadata candidates.', {
+            nextActions: ['Retry with `--limit 5` or lower.'],
+            details: { candidateCount, maximum: 5 },
+        });
+    }
+    const byteLength = Buffer.byteLength(JSON.stringify(envelope.result), 'utf8');
+    if (byteLength > 2_048) {
+        throw new AgentAssetsError('schema_incompatible', 'Discovery metadata result exceeds the 2 KiB pre-body budget.', {
+            nextActions: ['Narrow the query or reduce `--limit`; do not load candidate bodies to compensate.'],
+            details: { byteLength, maximumBytes: 2_048 },
+        });
+    }
+}

package/dist/lib/agent-assets/gateway.js

@@ -0,0 +1,15 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+export const AOPS_AGENT_ASSETS_GATEWAY_RELATIVE_PATH = 'skills/aops/SKILL.md';
+const BUNDLED_GATEWAY = typeof __AOPS_AGENT_ASSETS_GATEWAY_TEXT__ === 'undefined'
+    ? undefined
+    : __AOPS_AGENT_ASSETS_GATEWAY_TEXT__;
+export const AOPS_AGENT_ASSETS_GATEWAY_SOURCE_URL = BUNDLED_GATEWAY === undefined
+    ? new URL('../../../assets/agent-assets/gateway/aops/SKILL.md', import.meta.url)
+    : undefined;
+export const AOPS_AGENT_ASSETS_GATEWAY = BUNDLED_GATEWAY
+    ?? fs.readFileSync(AOPS_AGENT_ASSETS_GATEWAY_SOURCE_URL, 'utf8');
+export const AOPS_AGENT_ASSETS_GATEWAY_SHA256 = crypto
+    .createHash('sha256')
+    .update(AOPS_AGENT_ASSETS_GATEWAY, 'utf8')
+    .digest('hex');

package/dist/lib/agent-assets/guards.js

@@ -0,0 +1,23 @@
+import { AgentAssetsError } from './envelope.js';
+export function resolveAgentAssetsMutationGuard(input) {
+    if (!input.apply) {
+        const confirmFlag = input.destructive ? ' --confirm' : '';
+        return Object.freeze({
+            mode: 'preview',
+            mutationFree: true,
+            action: input.action,
+            nextActions: Object.freeze([
+                `Review this preview, then re-run with --apply${confirmFlag} to execute it.`,
+            ]),
+        });
+    }
+    if (input.destructive && !input.confirm) {
+        throw new AgentAssetsError('recovery_confirmation_required', `${input.action} requires both --apply and --confirm.`, { nextActions: [`Re-run ${input.action} with --apply --confirm after reviewing status and the preview.`] });
+    }
+    return Object.freeze({
+        mode: 'apply',
+        mutationFree: false,
+        action: input.action,
+        nextActions: Object.freeze([]),
+    });
+}

package/dist/lib/agent-assets/hosted-discovery.js

@@ -0,0 +1,148 @@
+import { invokeHostedToolWithApiState, unwrapHostedToolResult } from '../../utils/agent-gateway.js';
+import { createCliApiClientFromOptions } from '../../utils/api.js';
+import { AgentAssetsError } from './envelope.js';
+const MATCH_FIELD = /^(?:name|shortDescription|description|tags|version|entryFile|skillStandard|meta\.[A-Za-z0-9_.-]+)$/;
+const EXACT_REF = /^skill-version:(.+)$/;
+const SHA256_HEX = /^[a-f0-9]{64}$/;
+const FORBIDDEN_BODY_KEYS = new Set([
+    'content',
+    'files',
+    'filesystemPath',
+    'materializedPath',
+    'outputDir',
+    'packagePath',
+    'serverPath',
+    'sourcePath',
+]);
+function discoveryError(message, details) {
+    return new AgentAssetsError('schema_incompatible', message, {
+        nextActions: [
+            'Inspect `aops-cli agent schema --tool agentspace.skill.search --summary`; do not load skill bodies to compensate.',
+        ],
+        ...(details === undefined ? {} : { details }),
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function unwrapData(value) {
+    let current = value;
+    for (let depth = 0; depth < 3; depth += 1) {
+        if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, 'data'))
+            break;
+        current = current.data;
+    }
+    return current;
+}
+function assertMetadataOnly(value) {
+    if (!value || typeof value !== 'object')
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (FORBIDDEN_BODY_KEYS.has(key)) {
+            throw new AgentAssetsError('untrusted_origin', `Hosted discovery returned forbidden body/path field: ${key}.`, {
+                nextActions: ['Use only the raw metadata `agentspace.skill.search` Community projection.'],
+            });
+        }
+        assertMetadataOnly(child);
+    }
+}
+function boundedString(record, key, maximum, required = true) {
+    const value = record[key];
+    if (value === undefined && !required)
+        return undefined;
+    if (typeof value !== 'string' || value.length < 1 || value.length > maximum) {
+        throw discoveryError(`Hosted discovery candidate.${key} is invalid or exceeds its metadata budget.`);
+    }
+    return value;
+}
+export function validateHostedSkillDiscovery(payload, options) {
+    assertMetadataOnly(payload);
+    const candidate = unwrapData(payload);
+    if (!isRecord(candidate))
+        throw discoveryError('Hosted skill search result must be an object.');
+    const query = boundedString(candidate, 'query', 256);
+    const normalizedQuery = boundedString(candidate, 'normalizedQuery', 256);
+    if (!Array.isArray(candidate.candidates) || candidate.candidates.length > options.limit || candidate.candidates.length > 5) {
+        throw discoveryError('Hosted skill search exceeded the requested candidate limit.', {
+            requestedLimit: options.limit,
+            candidateCount: Array.isArray(candidate.candidates) ? candidate.candidates.length : null,
+        });
+    }
+    if (candidate.count !== candidate.candidates.length) {
+        throw discoveryError('Hosted skill search count does not match its candidate array.');
+    }
+    const candidates = candidate.candidates.map((entry, index) => {
+        if (!isRecord(entry))
+            throw discoveryError(`Hosted skill search candidate ${index} must be an object.`);
+        const versionId = boundedString(entry, 'versionId', 160);
+        const exactRef = boundedString(entry, 'exactRef', 180);
+        const match = EXACT_REF.exec(exactRef);
+        if (!match || match[1] !== versionId) {
+            throw discoveryError(`Hosted skill search candidate ${index} has inconsistent exact identity.`);
+        }
+        if (entry.origin !== 'hosted')
+            throw discoveryError(`Hosted skill search candidate ${index} has an invalid origin.`);
+        const packageSha256 = boundedString(entry, 'packageSha256', 64);
+        const contentSha256 = boundedString(entry, 'contentSha256', 64);
+        if (!SHA256_HEX.test(packageSha256) || !SHA256_HEX.test(contentSha256)) {
+            throw discoveryError(`Hosted skill search candidate ${index} has invalid immutable digest metadata.`);
+        }
+        if (entry.computedTrustClass !== 'verified-hosted-package') {
+            throw discoveryError(`Hosted skill search candidate ${index} has an invalid computed trust class.`);
+        }
+        if (!Number.isSafeInteger(entry.score) || entry.score < 1) {
+            throw discoveryError(`Hosted skill search candidate ${index} has an invalid score.`);
+        }
+        if (!Array.isArray(entry.matchedBy)
+            || entry.matchedBy.length < 1
+            || entry.matchedBy.length > 5
+            || entry.matchedBy.some((field) => typeof field !== 'string' || !MATCH_FIELD.test(field))
+            || new Set(entry.matchedBy).size !== entry.matchedBy.length) {
+            throw discoveryError(`Hosted skill search candidate ${index} has invalid match metadata.`);
+        }
+        return Object.freeze({
+            name: boundedString(entry, 'name', 80),
+            version: boundedString(entry, 'version', 80),
+            versionId,
+            exactRef,
+            packageSha256,
+            contentSha256,
+            ...(entry.shortDescription === undefined
+                ? {}
+                : { shortDescription: boundedString(entry, 'shortDescription', 96, false) }),
+            origin: 'hosted-cache',
+            computedTrustClass: 'verified-hosted-package',
+            score: entry.score,
+            matchedBy: Object.freeze([...entry.matchedBy]),
+            rationale: boundedString(entry, 'rationale', 160),
+        });
+    });
+    return Object.freeze({ query, normalizedQuery, candidates: Object.freeze(candidates) });
+}
+export async function discoverHostedSkills(options) {
+    let payload;
+    try {
+        const input = Object.freeze({ query: options.query, limit: options.limit });
+        if (options.invoke) {
+            payload = await options.invoke('agentspace.skill.search', input);
+        }
+        else {
+            const apiState = await createCliApiClientFromOptions({ apiBaseUrl: options.apiBaseUrl });
+            const response = await invokeHostedToolWithApiState(apiState, {
+                apiBaseUrl: options.apiBaseUrl,
+                toolId: 'agentspace.skill.search',
+                input,
+            });
+            payload = unwrapHostedToolResult(response);
+        }
+    }
+    catch (error) {
+        if (error instanceof AgentAssetsError)
+            throw error;
+        throw new AgentAssetsError('remote_unavailable', 'Hosted skill metadata search failed.', {
+            nextActions: ['Retry when the selected AOPS server is reachable, or use `--offline` for the installed core only.'],
+            cause: error,
+        });
+    }
+    return validateHostedSkillDiscovery(payload, options);
+}

package/dist/lib/agent-assets/hosted-package-input.js

@@ -0,0 +1,154 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { invokeHostedToolWithApiState, unwrapHostedToolResult } from '../../utils/agent-gateway.js';
+import { createCliApiClientFromOptions } from '../../utils/api.js';
+import { AgentAssetsError } from './envelope.js';
+import { validatePortablePackageV1 } from './package-manifest.js';
+import { canonicalJsonV1 } from './store-reader.js';
+const FORBIDDEN_SERVER_PATH_KEYS = new Set([
+    'filesystemPath',
+    'materializedPath',
+    'outputDir',
+    'packagePath',
+    'serverPath',
+    'sourcePath',
+]);
+function packageError(code, message, details) {
+    return new AgentAssetsError(code, message, {
+        nextActions: [
+            'Inspect the exact hosted contract with `aops-cli agent schema --tool agentspace.skill-version.export-skill-package --summary`.',
+        ],
+        ...(details === undefined ? {} : { details }),
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function unwrapData(value) {
+    let current = value;
+    for (let depth = 0; depth < 3; depth += 1) {
+        if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, 'data'))
+            break;
+        current = current.data;
+    }
+    return current;
+}
+function assertNoServerFilesystemPointers(value) {
+    if (!value || typeof value !== 'object')
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (FORBIDDEN_SERVER_PATH_KEYS.has(key) && typeof child === 'string' && child.trim()) {
+            throw packageError('untrusted_origin', `Hosted client export leaked a server filesystem field: ${key}.`);
+        }
+        assertNoServerFilesystemPointers(child);
+    }
+}
+function nonEmpty(record, key, label) {
+    const value = record[key];
+    if (typeof value !== 'string' || !value.trim()) {
+        throw packageError('schema_incompatible', `${label}.${key} must be a non-empty string.`);
+    }
+    return value;
+}
+function readExpectedManifest(reference, versionId) {
+    if (!reference.startsWith('@')) {
+        if (reference !== `skill-version:${versionId}`) {
+            throw packageError('expected_manifest_required', 'Expected manifest must be @file.json or the exact immutable skill-version ref.', {
+                expected: `skill-version:${versionId}`,
+            });
+        }
+        return null;
+    }
+    const filePath = path.resolve(reference.slice(1));
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        throw packageError('expected_manifest_required', 'Expected manifest file could not be read.', {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+    if (Buffer.byteLength(raw, 'utf8') > 1024 * 1024) {
+        throw packageError('schema_incompatible', 'Expected manifest exceeds the 1 MiB input limit.');
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw packageError('schema_incompatible', 'Expected manifest is not valid JSON.');
+    }
+}
+export function assertExpectedSkillPackageManifestV1(reference, versionId, manifest) {
+    if (manifest.assetKind !== 'skill-package' ||
+        manifest.versionId !== versionId ||
+        manifest.provenance.reference !== `skill-version:${versionId}`) {
+        throw packageError('untrusted_origin', 'Package manifest does not identify the exact immutable skill version.');
+    }
+    const expectedManifest = readExpectedManifest(reference, versionId);
+    if (expectedManifest !== null && canonicalJsonV1(expectedManifest) !== canonicalJsonV1(manifest)) {
+        throw packageError('hash_mismatch', 'Immutable manifest differs from the caller-pinned expected manifest.');
+    }
+}
+export function validateHostedSkillPackageExport(payload, options) {
+    assertNoServerFilesystemPointers(payload);
+    const candidate = unwrapData(payload);
+    if (!isRecord(candidate))
+        throw packageError('schema_incompatible', 'Hosted export result must be an object.');
+    const skillVersionId = nonEmpty(candidate, 'skillVersionId', 'HostedSkillPackageExport');
+    if (skillVersionId !== options.versionId) {
+        throw packageError('hash_mismatch', 'Hosted export returned a different immutable skill version.');
+    }
+    if (!Array.isArray(candidate.files) || candidate.files.length === 0) {
+        throw packageError('schema_incompatible', 'Hosted export did not include package files.');
+    }
+    const transferFiles = candidate.files.map((file, index) => {
+        if (!isRecord(file) || typeof file.path !== 'string' || typeof file.content !== 'string') {
+            throw packageError('schema_incompatible', `Hosted export file ${index} must contain path and UTF-8 content.`);
+        }
+        return { path: file.path, bytes: Buffer.from(file.content, 'utf8') };
+    });
+    const validation = validatePortablePackageV1(candidate.manifest, transferFiles);
+    if (!validation.ok) {
+        throw packageError('hash_mismatch', 'Hosted package bytes do not match immutable publish-time metadata.', {
+            issues: validation.issues,
+        });
+    }
+    const manifest = validation.value.normalizedManifest;
+    assertExpectedSkillPackageManifestV1(options.expectedManifest, skillVersionId, manifest);
+    return {
+        skillVersionId,
+        skillId: nonEmpty(candidate, 'skillId', 'HostedSkillPackageExport'),
+        skillName: nonEmpty(candidate, 'skillName', 'HostedSkillPackageExport'),
+        projectId: nonEmpty(candidate, 'projectId', 'HostedSkillPackageExport'),
+        scopeId: nonEmpty(candidate, 'scopeId', 'HostedSkillPackageExport'),
+        manifest,
+        transferFiles,
+        validation: validation.value,
+    };
+}
+export async function pullHostedSkillPackage(options) {
+    let payload;
+    try {
+        if (options.invoke) {
+            payload = await options.invoke('agentspace.skill-version.export-skill-package', { id: options.versionId });
+        }
+        else {
+            const apiState = await createCliApiClientFromOptions({ apiBaseUrl: options.apiBaseUrl });
+            const response = await invokeHostedToolWithApiState(apiState, {
+                apiBaseUrl: options.apiBaseUrl,
+                toolId: 'agentspace.skill-version.export-skill-package',
+                input: { id: options.versionId },
+            });
+            payload = unwrapHostedToolResult(response);
+        }
+    }
+    catch (error) {
+        if (error instanceof AgentAssetsError)
+            throw error;
+        throw packageError('remote_unavailable', 'Hosted skill package export failed.', {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return validateHostedSkillPackageExport(payload, options);
+}