@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.74

package/dist/hooks/yaml-plugin.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YamlHookPlugin = void 0;
+exports.validateHooksSchema = validateHooksSchema;
+const plugin_1 = require("./plugin");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_fs_1 = require("node:fs");
+const glob_match_1 = require("../utils/glob-match");
+const dispatch_1 = require("./dispatch");
+const MAX_FILE_SIZE_FOR_LINE_COUNT = 10 * 1024 * 1024;
+const SIZE_UNITS = {
+    b: 1,
+    kb: 1024,
+    mb: 1024 * 1024,
+    gb: 1024 * 1024 * 1024,
+};
+function matches(selector, value) {
+    if (selector === undefined)
+        return true;
+    if (Array.isArray(selector))
+        return selector.includes(value);
+    return selector === value;
+}
+function matchesAny(selector, values) {
+    if (selector === undefined)
+        return true;
+    if (Array.isArray(selector))
+        return selector.some(s => values.includes(s));
+    return values.includes(selector);
+}
+function parseSizeValue(val) {
+    if (typeof val === 'number')
+        return val;
+    const match = val.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i);
+    if (!match)
+        return 0;
+    const num = parseFloat(match[1]);
+    const unit = (match[2] ?? 'b').toLowerCase();
+    return Math.floor(num * (SIZE_UNITS[unit] ?? 1));
+}
+function isSizeInBytes(val) {
+    return typeof val === 'string';
+}
+function getFileLineCount(filePath) {
+    try {
+        const stat = (0, node_fs_1.statSync)(filePath);
+        if (stat.size > MAX_FILE_SIZE_FOR_LINE_COUNT) {
+            process.stderr.write(`[YamlHookPlugin] File too large for line count: ${filePath} (${stat.size} bytes)\n`);
+            return null;
+        }
+        const content = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+        return content.split('\n').length;
+    }
+    catch {
+        return null;
+    }
+}
+function getFileSizeBytes(filePath) {
+    try {
+        return (0, node_fs_1.statSync)(filePath).size;
+    }
+    catch {
+        return null;
+    }
+}
+function matchPathPattern(pathPattern, toolInput, cwd) {
+    if (!pathPattern)
+        return true;
+    const input = toolInput;
+    const path = input?.path ?? input?.file_path ?? input?.filePath ?? input?.filename;
+    if (typeof path !== 'string')
+        return false;
+    if ((0, glob_match_1.matchesPattern)(path, pathPattern))
+        return true;
+    // Provider가 절대경로를 보내는 경우(Claude Read 등) cwd 기준 상대경로로도 시도.
+    if (cwd && path.startsWith('/')) {
+        const { relative, isAbsolute } = require('node:path');
+        if (isAbsolute(path)) {
+            const rel = relative(cwd, path);
+            if (rel && !rel.startsWith('..') && (0, glob_match_1.matchesPattern)(rel, pathPattern))
+                return true;
+        }
+    }
+    return false;
+}
+function matchPattern(pattern, toolInput) {
+    if (!pattern)
+        return true;
+    const inputStr = JSON.stringify(toolInput);
+    return inputStr.includes(pattern);
+}
+function matchRegex(regex, toolInput) {
+    if (!regex)
+        return true;
+    try {
+        const re = new RegExp(regex);
+        const inputStr = JSON.stringify(toolInput);
+        return re.test(inputStr);
+    }
+    catch {
+        return false;
+    }
+}
+function matchWhenInputRegex(regex, toolInput) {
+    if (!regex)
+        return true;
+    try {
+        const re = new RegExp(regex);
+        const inputStr = JSON.stringify(toolInput);
+        return re.test(inputStr);
+    }
+    catch {
+        return false;
+    }
+}
+function matchPathSize(rule, toolInput) {
+    if (rule.pathSizeMin === undefined && rule.pathSizeMax === undefined)
+        return true;
+    const input = toolInput;
+    const filePath = input?.path ?? input?.file_path ?? input?.filePath ?? input?.filename;
+    if (typeof filePath !== 'string')
+        return false;
+    if (rule.pathSizeMin !== undefined) {
+        if (isSizeInBytes(rule.pathSizeMin)) {
+            const sizeBytes = getFileSizeBytes(filePath);
+            if (sizeBytes === null)
+                return false;
+            if (sizeBytes < parseSizeValue(rule.pathSizeMin))
+                return false;
+        }
+        else {
+            const lineCount = getFileLineCount(filePath);
+            if (lineCount === null)
+                return false;
+            if (lineCount < rule.pathSizeMin)
+                return false;
+        }
+    }
+    if (rule.pathSizeMax !== undefined) {
+        if (isSizeInBytes(rule.pathSizeMax)) {
+            const sizeBytes = getFileSizeBytes(filePath);
+            if (sizeBytes === null)
+                return false;
+            if (sizeBytes > parseSizeValue(rule.pathSizeMax))
+                return false;
+        }
+        else {
+            const lineCount = getFileLineCount(filePath);
+            if (lineCount === null)
+                return false;
+            if (lineCount > rule.pathSizeMax)
+                return false;
+        }
+    }
+    return true;
+}
+function validateHooksSchema(hooks) {
+    const valid = [];
+    const warnings = [];
+    for (let i = 0; i < hooks.length; i++) {
+        const entry = hooks[i];
+        if (!entry || typeof entry !== 'object') {
+            warnings.push(`Hook at index ${i}: not an object, skipping`);
+            continue;
+        }
+        const obj = entry;
+        if (typeof obj.name !== 'string' || !obj.name) {
+            warnings.push(`Hook at index ${i}: missing or invalid "name", skipping`);
+            continue;
+        }
+        const hasGuide = obj.guide && typeof obj.guide === 'object';
+        const hasDeny = obj.deny && typeof obj.deny === 'object';
+        const hasPlugin = typeof obj.plugin === 'string';
+        if (!hasGuide && !hasDeny && !hasPlugin) {
+            warnings.push(`Hook "${obj.name}": missing guide/deny/plugin, skipping`);
+            continue;
+        }
+        if (hasGuide) {
+            const guide = obj.guide;
+            if (typeof guide.say !== 'string') {
+                warnings.push(`Hook "${obj.name}": guide.say is required and must be string, skipping`);
+                continue;
+            }
+        }
+        if (hasDeny) {
+            const deny = obj.deny;
+            if (typeof deny.reason !== 'string') {
+                warnings.push(`Hook "${obj.name}": deny.reason is required and must be string, skipping`);
+                continue;
+            }
+        }
+        valid.push(obj);
+    }
+    return { valid, warnings };
+}
+class YamlHookPlugin extends plugin_1.HookPlugin {
+    name = '@crewx/yaml-hook-plugin';
+    version = '0.1.0';
+    capabilities = { required: ['inject'] };
+    hooks;
+    agentMap;
+    constructor(config) {
+        super();
+        this.hooks = config.hooks;
+        this.agentMap = new Map((config.agents ?? []).map(a => [a.id, a]));
+    }
+    async run(ctx) {
+        const injected = [];
+        const logPath = process.env.CREWX_TASK_LOG_PATH;
+        const verbose = process.env.CREWX_HOOK_LOG_VERBOSE === '1';
+        for (const entry of this.hooks) {
+            if (!this.matchEntryLevel(entry, ctx))
+                continue;
+            if (!entry.guide)
+                continue;
+            if (!this.matchRuleLevel(entry.guide, ctx)) {
+                if (verbose && logPath) {
+                    this.appendHookLog(logPath, {
+                        rule: entry.name,
+                        action: 'pass',
+                        once: entry.guide.once ?? false,
+                        ctx,
+                        matched: false,
+                    });
+                }
+                continue;
+            }
+            if (entry.guide.once && this.hasFired(ctx.sessionId, entry.name))
+                continue;
+            if (entry.guide.once)
+                this.markFired(ctx.sessionId, entry.name);
+            injected.push(entry.guide.say);
+            if (logPath) {
+                this.appendHookLog(logPath, {
+                    rule: entry.name,
+                    action: 'inject',
+                    once: entry.guide.once ?? false,
+                    ctx,
+                    matched: true,
+                    message: entry.guide.say,
+                });
+            }
+        }
+        return injected.length ? ctx.inject(injected.join('\n\n')) : ctx.pass();
+    }
+    appendHookLog(logPath, opts) {
+        try {
+            const entry = {
+                rule: opts.rule,
+                action: opts.action,
+                once: opts.once,
+                sessionId: opts.ctx.sessionId,
+                provider: opts.ctx.provider,
+                agent: opts.ctx.agent.id,
+                toolName: opts.ctx.tool.name,
+                rawToolName: opts.ctx.tool.rawName,
+            };
+            if (opts.message) {
+                entry.chars = opts.message.length;
+                if (process.env.CREWX_HOOK_LOG_VERBOSE === '1') {
+                    entry.message = (0, dispatch_1.sanitizeInjectMessage)(opts.message).slice(0, 500);
+                }
+            }
+            const line = `[${new Date().toISOString()}] HOOK: ${JSON.stringify(entry)}\n`;
+            (0, node_fs_1.appendFileSync)(logPath, line, { encoding: 'utf8', mode: 0o600 });
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    matchEntryLevel(entry, ctx) {
+        if (entry.provider !== undefined) {
+            const provider = ctx.provider.replace(/^cli\//, '');
+            if (!matches(entry.provider, provider))
+                return false;
+        }
+        if (entry.team !== undefined) {
+            const agent = this.agentMap.get(ctx.agent.id);
+            const team = agent?.team ?? ctx.agent.team;
+            if (!matches(entry.team, team))
+                return false;
+        }
+        if (entry.role !== undefined) {
+            const agent = this.agentMap.get(ctx.agent.id);
+            const role = agent?.role ?? ctx.agent.role;
+            if (!matches(entry.role, role))
+                return false;
+        }
+        if (entry.tag !== undefined) {
+            const agent = this.agentMap.get(ctx.agent.id);
+            const tags = agent?.tags ?? [];
+            if (!matchesAny(entry.tag, tags))
+                return false;
+        }
+        if (entry.agents !== undefined) {
+            if (!entry.agents.includes(ctx.agent.id))
+                return false;
+        }
+        return true;
+    }
+    matchRuleLevel(rule, ctx) {
+        if (rule.when !== undefined && rule.when.length > 0) {
+            if (!rule.when.includes(ctx.tool.name) && !rule.when.includes(ctx.tool.rawName))
+                return false;
+        }
+        if (!matchPattern(rule.pattern, ctx.tool.input))
+            return false;
+        if (!matchRegex(rule.regex, ctx.tool.input))
+            return false;
+        if (!matchPathPattern(rule.pathPattern, ctx.tool.input, ctx.cwd))
+            return false;
+        if (!matchPathSize(rule, ctx.tool.input))
+            return false;
+        if (!matchWhenInputRegex(rule.whenInputRegex, ctx.tool.input))
+            return false;
+        return true;
+    }
+    hasFired(sessionId, ruleName) {
+        try {
+            const path = this.firedFilePath(sessionId);
+            if (!(0, node_fs_1.existsSync)(path))
+                return false;
+            const state = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+            return Array.isArray(state.fired) && state.fired.includes(ruleName);
+        }
+        catch {
+            return false;
+        }
+    }
+    markFired(sessionId, ruleName) {
+        try {
+            const path = this.firedFilePath(sessionId);
+            (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true, mode: 0o700 });
+            const state = (0, node_fs_1.existsSync)(path)
+                ? JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'))
+                : { fired: [] };
+            if (!Array.isArray(state.fired))
+                state.fired = [];
+            if (!state.fired.includes(ruleName)) {
+                state.fired.push(ruleName);
+                (0, node_fs_1.writeFileSync)(path, JSON.stringify(state), { mode: 0o600 });
+            }
+        }
+        catch (e) {
+            process.stderr.write(`[YamlHookPlugin] once state write failed: ${e}\n`);
+        }
+    }
+    firedFilePath(sessionId) {
+        const safe = (0, node_crypto_1.createHash)('sha1').update(sessionId).digest('hex');
+        return (0, node_path_1.join)((0, node_os_1.homedir)(), '.crewx', 'sessions', safe, 'fired-rules.json');
+    }
+}
+exports.YamlHookPlugin = YamlHookPlugin;
+//# sourceMappingURL=yaml-plugin.js.map

package/dist/index.browser.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @crewx/sdk browser entry point.
+ *
+ * Exports only browser-safe modules — no Node.js dependencies
+ * (child_process, fs, path, crypto, events).
+ */
+export { Crewx } from './facade/Crewx.browser.js';
+export type { ToolDefinition, BrowserQueryOptions, BrowserFromConfigOptions } from './facade/Crewx.browser.js';
+export { registerProviderFactory, createProvider, ProviderError } from './provider/bridge.browser.js';
+export type { ProviderRuntime, ProviderFactory, ProviderQueryOptions } from './provider/bridge.browser.js';
+export { parseYamlContent, ConfigLoadError } from './config/loader.browser.js';
+export { BrowserFsAdapter } from './platform/BrowserFsAdapter.js';
+export type { IFsAdapter } from './platform/IFsAdapter.js';
+export type { AgentConfig, CrewxProjectConfig, CrewxOptions, QueryOptions, QueryResult, ExecuteOptions, ExecuteResult, } from './types/index.js';
+//# sourceMappingURL=index.browser.d.ts.map

package/dist/index.browser.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @crewx/sdk browser entry point.
+ *
+ * Exports only browser-safe modules — no Node.js dependencies
+ * (child_process, fs, path, crypto, events).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserFsAdapter = exports.ConfigLoadError = exports.parseYamlContent = exports.ProviderError = exports.createProvider = exports.registerProviderFactory = exports.Crewx = void 0;
+// Browser-safe facade
+var Crewx_browser_js_1 = require("./facade/Crewx.browser.js");
+Object.defineProperty(exports, "Crewx", { enumerable: true, get: function () { return Crewx_browser_js_1.Crewx; } });
+// Browser-safe provider bridge (registry only, no CLI spawn)
+var bridge_browser_js_1 = require("./provider/bridge.browser.js");
+Object.defineProperty(exports, "registerProviderFactory", { enumerable: true, get: function () { return bridge_browser_js_1.registerProviderFactory; } });
+Object.defineProperty(exports, "createProvider", { enumerable: true, get: function () { return bridge_browser_js_1.createProvider; } });
+Object.defineProperty(exports, "ProviderError", { enumerable: true, get: function () { return bridge_browser_js_1.ProviderError; } });
+// Config — browser-safe (no fs import)
+var loader_browser_js_1 = require("./config/loader.browser.js");
+Object.defineProperty(exports, "parseYamlContent", { enumerable: true, get: function () { return loader_browser_js_1.parseYamlContent; } });
+Object.defineProperty(exports, "ConfigLoadError", { enumerable: true, get: function () { return loader_browser_js_1.ConfigLoadError; } });
+// Platform adapters
+var BrowserFsAdapter_js_1 = require("./platform/BrowserFsAdapter.js");
+Object.defineProperty(exports, "BrowserFsAdapter", { enumerable: true, get: function () { return BrowserFsAdapter_js_1.BrowserFsAdapter; } });
+//# sourceMappingURL=index.browser.js.map

package/dist/index.d.ts

@@ -1,59 +1,71 @@
-export { SERVER_NAME, PREFIX_TOOL_NAME, DEFAULT_MAX_FILE_SIZE, DEFAULT_MAX_FILES, } from './constants';
-export type { TimeoutConfig } from './config/timeout.config';
-export { getTimeoutConfig, getDefaultTimeoutConfig } from './config/timeout.config';
-export type { ModelPricing, PricingTable } from './config/pricing';
-export { MODEL_PRICING, getPricing, calculateCost } from './config/pricing';
-export { parseAPIProviderConfig, parseMCPServers, parseCrewXConfig, validateAPIProviderConfig, substituteEnvVars, APIProviderParseError, type RawAgentConfig, type RawYAMLConfig, type RawMCPServerConfig, } from './config/api-provider-parser';
-export type { BaseMessage, ConversationMessage, ConversationThread, FetchHistoryOptions, IConversationHistoryProvider, MessageFileAttachment, } from './conversation/conversation-history.interface';
-export type { ConversationConfig } from './conversation/conversation-config';
-export { DEFAULT_CONVERSATION_CONFIG, getConversationConfig, } from './conversation/conversation-config';
-export { DocumentManager } from './knowledge/DocumentManager';
-export { ProviderNamespace, BuiltInProviders, ProviderNotAvailableError, } from './core/providers/ai-provider.interface';
-export type { ProviderNamespaceType, AIProvider, AIQueryOptions, AIResponse, } from './core/providers/ai-provider.interface';
-export { BaseAIProvider, resolveCallerAgentId } from './core/providers/base-ai.provider';
-export { ClaudeProvider, GeminiProvider, CopilotProvider, CodexProvider, BaseDynamicProviderFactory, MockProvider, createProviderFromConfig, } from './core/providers';
-export type { BaseAIProviderOptions, LoggerLike, AIProviderConfig, ProviderTaskLogEntry, ProviderTaskLogHandler, ProviderTaskLogLevel, } from './core/providers/base-ai.types';
-export type { PluginProviderConfig, RemoteProviderConfig, APIProviderFactoryConfig, DynamicProviderConfig, DynamicProviderFactoryOptions, } from './core/providers/dynamic-provider.factory';
-export type { ProviderConfig, ProviderInput, ProviderResolutionResult, } from './types/provider.types';
-export type { APIProviderConfig, APIProviderType, ProviderExecutionMode, ProviderModeOptions, ProviderOptions, LegacyProviderPermissionConfig, CrewXInstance, FrameworkToolDefinition, MCPServerConfig, ToolExecutionContext as APIToolExecutionContext, } from './types/api-provider.types';
-export { API_PROVIDER_TYPES, isLegacyProviderPermissionConfig, isProviderModeOptions, isProviderOptions, convertLegacyPermissionsToProviderOptions, } from './types/api-provider.types';
-export { APIProviderConfigSchema, MCPServerConfigSchema, APIProviderConfigJsonSchema, } from './schemas/api-provider.schema';
-export type { Tool, ToolExecutionContext, ToolExecutionResult, ToolCallHandler, } from './core/providers/tool-call.types';
-export { normalizeAPIProviderConfig, getModePermissions, isAPIProviderConfig, assertAPIProviderConfig, } from './utils/api-provider-normalizer';
-export type { NormalizedAPIProviderConfigResult, ModePermissionBuckets, } from './utils/api-provider-normalizer';
+/**
+ * @crewx/sdk public API surface.
+ */
+export { Crewx } from './facade/Crewx';
+export type { ToolDefinition } from './facade/Crewx';
+export { CrewxPlugin } from './plugin';
+export { TypedEventEmitter } from './events/TypedEventEmitter';
+export type { CrewxEvents, CrewxEventName, CrewxEventPayload, BaseEvent, TaskStartEvent, TaskEndEvent, TaskOutputEvent, AdapterLifecycleEvent, AdapterMessageEvent, UnsubscribeFn, } from './events/types';
+export type { LayoutSpec, RenderAgentPromptOptions, SkillEntry } from './facade/Crewx';
+export { LayoutLoader } from './layout/loader';
+export { LayoutRenderer } from './layout/renderer';
+export type { RenderOptions } from './layout/renderer';
+export { PropsValidator } from './layout/props-validator';
+export type { LayoutDefinition, CustomLayoutDefinition, InlineLayoutSpec, LoaderOptions, RenderContext, PropSchema, ValidationResult, ValidationError, TemplateVars, RawLayoutYaml, } from './layout/types';
+export { LayoutLoadError, PropsValidationError } from './layout/types';
+export { TemplateEngine } from './template/engine';
+export type { ExecPolicy, TemplateContext, TemplateEngineOptions } from './template/types';
+export { DocumentLoader } from './template/loader/DocumentLoader';
+export type { IFsAdapter } from './platform/IFsAdapter';
+export { NodeFsAdapter, defaultFsAdapter } from './platform/NodeFsAdapter';
+export { BrowserFsAdapter } from './platform/BrowserFsAdapter';
+export { truncateHelper, lengthHelper, escapeHandlebarsHelper, formatFileSizeHelper, formatTimestampHelper, } from './template/helpers/p1p2';
+export { setAuditVerbose } from './template/helpers/exec';
+export type { AgentConfig, CrewxProjectConfig, CrewxOptions, QueryOptions, QueryResult, ExecuteOptions, ExecuteResult, YamlHookEntry, GuideRule, } from './types';
+export { loadYamlFile, parseYamlContent, ConfigLoadError } from './config/loader';
+export { resolveAgent, AgentNotFoundError } from './agent/resolver';
+export { createProvider, ProviderError, ClientToolCallRequiredError, registerProviderFactory } from './provider/bridge';
+export type { ProviderRuntime, ProviderQueryOptions, ProviderFactory, ClientToolCall, ContinuationState } from './provider/bridge';
+export { VercelProviderRuntime } from './provider/vercel-runtime';
+export type { VercelProviderConfig } from './provider/vercel-runtime';
+export { registerApiProviders } from './provider/register-api';
+export { createDelegateTool } from './tools/delegate';
+export { resolveCrewxCli, resolveCrewxWorkspace } from './utils/env-defaults';
+export { generateId, generateFingerprint } from './utils/id';
+export type { EntityPrefix, PrefixedId } from './utils/id';
+export { hashWorkspaceId, normalizeWorkspacePath } from './utils/workspace';
+export { formatTimestamp } from './utils/timestamp';
 export type { TaskLogEntry, TaskLogEntryType } from './types/task-log.types';
-export { parseStdoutEvent } from './parsers';
-export { parseClaudeEvent } from './parsers';
-export { parseCopilotEvent } from './parsers';
-export { parseCodexEvent } from './parsers';
-export { parseGeminiEvent } from './parsers';
-export { isAgentCallCommand, parseAgentCall } from './parsers';
-export type { AgentAction, AgentConfig, AgentsConfig, AgentInfo, AgentQueryOptions, AgentResponse, RemoteAgentConfigInput, RemoteAgentInfo, } from './types/agent.types';
-export { ExecutionMode, SecurityLevel } from './types/agent.types';
-export { getErrorMessage, getErrorStack, isError } from './utils/error-utils';
-export { MentionParser, loadAvailableAgents, type MentionTask, type ParsedMentions, } from './utils/mention-parser';
-export { BaseMessageFormatter, DefaultMessageFormatter, type StructuredMessage as FormatterStructuredMessage, type FormatterOptions, } from './utils/base-message-formatter';
-export type { StructuredPayload, StructuredMessage, AgentInfo as StructuredAgentInfo, StructuredPayloadMetadata, } from './types/structured-payload.types';
-export { isStructuredPayload, parseStructuredPayload, createStructuredPayload, } from './types/structured-payload.types';
-export { createCrewxAgent, loadAgentConfigFromYaml, loadAgentConfigFromFile, resolveProvider, type CrewxAgent, type CrewxAgentConfig, type CrewxAgentResult, type ProviderConfig as AgentProviderConfig, type KnowledgeBaseConfig, } from './core/agent';
-export { type AgentQueryRequest, type AgentExecuteRequest, type AgentResult, type AgentRuntimeOptions, type CallStackFrame, type EventListener, } from './core/agent';
-export { RemoteAgentManager, FetchRemoteTransport, MockRemoteTransport, type RemoteAgentManagerOptions, } from './core/remote';
-export type { RemoteAgentConfig, RemoteTransport, RemoteTransportRequestOptions, RemoteAgentQueryRequest, RemoteAgentExecuteRequest, RemoteAgentResponse, McpJsonRpcRequest, McpJsonRpcResponse, ToolNameMapping, RemoteAgentDescriptor, } from './core/remote';
-export { ParallelRunner, ParallelRunnerTimeoutError, createDefaultParallelRunner, runQueriesParallel, runExecutesParallel, } from './core/parallel';
-export type { ParallelRunnerMetrics, ParallelRunnerOptions, Task, TaskResult, TaskCallbacks, TaskExecutionContext, ParallelConfig, HelperResult, RetryPolicy, } from './core/parallel';
-export { PropsValidator, type ValidationMode, } from './services/props-validator.service';
-export type { PropSchema, ValidationResult as PropsValidationResult, ValidationError as PropsValidationDetail, } from './types/layout.types';
-export { LayoutLoader } from './services/layout-loader.service';
-export { LayoutRenderer, PropsValidationError, type RenderOptions, type TemplateConfig, type ExecHelperConfig, } from './services/layout-renderer.service';
-export type { RenderContext, LayoutDefinition, ValidationResult, ValidationError, LoaderOptions, LayoutLoadError, InlineLayoutSpec, CustomLayoutDefinition, } from './types/layout.types';
-export type { BaseContext, TemplateContext, AgentMetadata, TemplateVars, } from './types/template.types';
-export type { SkillMetadata, SkillContent, SkillDefinition, SkillsConfig, CrewxProjectConfig, AgentDefinition, SkillParserOptions, SkillManifest, SkillsTrustConfig, } from './schema/skills.types';
-export { SkillLoadError, SkillNotFoundError, SkillDependencyError, SkillVersionMismatchError, } from './schema/skills.types';
-export { parseCrewxConfig, parseCrewxConfigFromFile, parseSkillManifest, parseSkillManifestFromFile, validateSkillMetadata, loadSkillContent, clearSkillCache, } from './schema/skills-parser';
-export { ProgressiveSkillLoader, ClaudeSkillAdapter, SystemRuntimeValidator, MockRuntimeValidator, } from './skills';
-export type { ISkillRuntime, IProgressiveSkillLoader, IClaudeSkillAdapter, RuntimeRequirementsValidator, SkillExecutionContext, SkillExecutionResult, SkillLoadOptions, SkillCacheStats, SkillRuntimeInfo, SkillRuntimeEvents, SkillRuntimeError, ProgressiveLoadingError, SkillExecutionError, SkillContextError, SDKExecutionContext, CLIExecutionContext, ProgressiveDisclosureConfig, RuntimeInfo, SkillBundleInfo, } from './skills';
-export { SdkBoxService, buildContext, approximateTokenCount, approximateTokenizer, } from './boxing';
-export type { BoxRow, BoxSummary, BoxResponse as SdkBoxResponse, ContextBuildParams, ContextBuildResponse, ThreadMessage as BoxingThreadMessage, InsertBoxData, CreateBoxParams, IBoxStorage, ITaskReader, ITokenizer, IBoxServiceReader, } from './boxing';
-export { generateId, generateFingerprint } from './core/id';
-export type { EntityPrefix, PrefixedId } from './core/id';
-export { hashWorkspaceId, normalizeWorkspacePath } from './core/workspace';
+export { SdkBoxService } from './boxing/box.service';
+export { buildContext } from './boxing/context-builder';
+export type { IBoxStorage, ITaskReader, ITokenizer } from './boxing/box-storage.interface';
+export type { BoxRow, BoxSummary, BoxResponse as SdkBoxResponse, InsertBoxData, CreateBoxParams, ThreadMessage as BoxingThreadMessage, ContextBuildParams, ContextBuildResponse, } from './boxing/box.types';
+export { parseStdoutEvent } from './parsers/router';
+export { parseUsage } from './provider/parse-usage';
+export type { ParsedUsage } from './provider/parse-usage';
+export { ParallelRunner, ParallelRunnerTimeoutError } from './parallel/parallel-runner';
+export type { Task, TaskResult, TaskExecutionContext, TaskCallbacks, ParallelRunnerOptions, ParallelRunnerMetrics, } from './parallel/types';
+export { runQueriesParallel, runExecutesParallel } from './parallel/helpers';
+export type { ParallelConfig, HelperResult, RetryPolicy } from './parallel/helpers';
+export { AgentRuntime } from './parallel/agent-runtime';
+export type { AgentResult, AgentQueryRequest, AgentExecuteRequest } from './parallel/agent-runtime';
+export { PluginProviderRuntime, createPluginProviderFactory } from './plugin/plugin-provider';
+export type { PluginProviderConfig } from './plugin/types';
+export { RemoteProviderRuntime, createRemoteProviderFactory } from './remote/remote-provider';
+export { RemoteAgentManager } from './remote/remote-agent-manager';
+export { McpHttpTransport } from './remote/remote-transport';
+export type { RemoteTransport, RemoteAgentConfig, RemoteProviderConfig, RemoteAgentQueryRequest, RemoteAgentExecuteRequest, RemoteAgentResponse, McpJsonRpcRequest, McpJsonRpcResponse, RemoteAgentDescriptor, } from './remote/types';
+export { createHandler } from './server/handler';
+export type { HandlerOptions, CrewxHandler } from './server/handler';
+export type { AuthOptions } from './server/auth';
+export { YamlHookPlugin, validateHooksSchema } from './hooks/yaml-plugin';
+export type { YamlHookConfig } from './hooks/yaml-plugin';
+export * from './conversation/index.js';
+export type { IChannelAdapter, AdapterContext, AdapterManifest, AdapterCapability, AdapterError as AdapterErrorClass, InboundMessage, OutboundMessage, RichCard, RichCardElement, InboundEvent, SendResult, HealthStatus, InstallState, InstallCallback, ChannelAdapterRegistration, HttpRouter, RouteOptions, RawRequest, RawResponse, Logger, AgentRunner, AdapterStore, BlobStorage, AuditSink, ResolvedUser, RouteResolution, EventResolution, } from './adapter/types';
+export { AdapterError } from './adapter/types';
+export { defineChannelAdapter, defineChannelAdapterPlugin } from './adapter/plugin-helper';
+export { createScopedAdapterStore } from './adapter/scoped-store';
+export { createAdapterContext, runInSyncWindow, getSyncWindowStore } from './adapter/context-builder';
+export type { SyncWindow, AdapterContextOptions } from './adapter/context-builder';
+export type { ChannelAdapterPluginSpec } from './adapter/plugin-helper';
+//# sourceMappingURL=index.d.ts.map