@capekai/core 1.0.0

package/README.md

@@ -0,0 +1,12 @@
+# @capekai/core
+
+Bun-native agent framework contracts and runtime implementations for composition, execution, hosts, providers, tools, sandbox, and storage.
+
+Requires Bun 1.3 or newer.
+
+## Install
+
+```bash
+npm install @capekai/core
+```
+Public subpaths include `composition`, `plugins`, `hosts`, `execution`, `providers`, `tools`, `ask-authority`, `sandbox`, `workspace`, `configuration`, `tool`, and `storage`.

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@capekai/core",
+  "version": "1.0.0",
+  "description": "Bun-native composable agent runtime and framework for Capek.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capek-dev/prokop.git",
+    "directory": "packages/capek"
+  },
+  "type": "module",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./composition": {
+      "types": "./src/internal/composition.ts",
+      "default": "./src/internal/composition.ts"
+    },
+    "./plugins": {
+      "types": "./src/internal/plugins.ts",
+      "default": "./src/internal/plugins.ts"
+    },
+    "./hosts": {
+      "types": "./src/internal/hosts.ts",
+      "default": "./src/internal/hosts.ts"
+    },
+    "./execution": {
+      "types": "./src/internal/execution.ts",
+      "default": "./src/internal/execution.ts"
+    },
+    "./providers": {
+      "types": "./src/internal/providers.ts",
+      "default": "./src/internal/providers.ts"
+    },
+    "./tools": {
+      "types": "./src/internal/tools.ts",
+      "default": "./src/internal/tools.ts"
+    },
+    "./ask-authority": {
+      "types": "./src/internal/ask-authority.ts",
+      "default": "./src/internal/ask-authority.ts"
+    },
+    "./sandbox": {
+      "types": "./src/internal/sandbox.ts",
+      "default": "./src/internal/sandbox.ts"
+    },
+    "./workspace": {
+      "types": "./src/internal/workspace.ts",
+      "default": "./src/internal/workspace.ts"
+    },
+    "./configuration": {
+      "types": "./src/internal/configuration.ts",
+      "default": "./src/internal/configuration.ts"
+    },
+    "./tool": {
+      "types": "./src/tool.ts",
+      "default": "./src/tool.ts"
+    },
+    "./storage": {
+      "types": "./src/storage.ts",
+      "default": "./src/storage.ts"
+    }
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ai-sdk/deepseek": "^2.0.35",
+    "@ai-sdk/openai": "^3.0.84",
+    "@capekai/tool": "^1.0.0",
+    "@capekai/types": "^1.0.0",
+    "@openrouter/ai-sdk-provider": "^2.3.3",
+    "@zip.js/zip.js": "^2.7.60",
+    "ai": "^6.0.116",
+    "ignore": "^7.0.3",
+    "picomatch": "^4.0.2",
+    "tar": "^7.5.13",
+    "vercel-minimax-ai-provider": "^0.0.2",
+    "zhipu-ai-provider": "^0.2.2"
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src tests",
+    "test": "bun test tests"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "@types/node": "^22.19.15",
+    "@types/picomatch": "^4.0.1",
+    "@types/tar": "^7.0.87",
+    "bun-types": "^1.3.9",
+    "typescript": "^5.7.2"
+  }
+}

package/src/adapters/ai-sdk.ts

@@ -0,0 +1,84 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import {
+  dynamicTool,
+  jsonSchema,
+  streamText,
+  type JSONSchema7,
+  type LanguageModel,
+  type Tool,
+} from 'ai';
+import { getModelWithMetadata } from '../core/model-utils';
+import type { ModelFactoryResult } from '../providers/types';
+
+export interface TextModelRequest {
+  modelId?: string;
+  providerId?: string;
+  systemPrompt: string;
+  prompt: string;
+  sessionId?: string;
+  maxOutputTokens?: number;
+  temperature?: number;
+}
+
+export async function runTextModel(request: TextModelRequest): Promise<string> {
+  const { model, omitMaxOutputTokens, providerOptions, useProviderInstructions } = await getModelWithMetadata({
+    modelId: request.modelId,
+    providerId: request.providerId,
+    systemPrompt: request.systemPrompt,
+    sessionId: request.sessionId,
+  });
+  const stream = streamText({
+    model,
+    system: useProviderInstructions ? undefined : request.systemPrompt,
+    prompt: request.prompt,
+    ...(omitMaxOutputTokens || request.maxOutputTokens === undefined
+      ? {}
+      : { maxOutputTokens: request.maxOutputTokens }),
+    temperature: request.temperature,
+    providerOptions: providerOptions as Parameters<typeof streamText>[0]['providerOptions'],
+  });
+  return stream.text;
+}
+
+export interface OpenAiResponsesModelRequest {
+  modelId: string;
+  apiKey: string;
+  fetch: typeof globalThis.fetch;
+  systemPrompt?: string;
+  sessionId?: string;
+}
+
+export function createOpenAiResponsesModel(request: OpenAiResponsesModelRequest): ModelFactoryResult {
+  const openai = createOpenAI({
+    apiKey: request.apiKey,
+    fetch: request.fetch,
+  });
+  return {
+    model: openai.responses(request.modelId) as unknown as LanguageModel,
+    useProviderInstructions: true,
+    omitMaxOutputTokens: true,
+    providerOptions: {
+      openai: {
+        instructions: request.systemPrompt || 'You are a helpful assistant.',
+        promptCacheKey: request.sessionId,
+        store: false,
+      },
+    },
+  };
+}
+
+export interface CapabilityToolRequest {
+  description: string;
+  inputSchema: Record<string, unknown>;
+  execute(args: unknown): Promise<unknown>;
+}
+
+export function createCapabilityTool(request: CapabilityToolRequest): Tool {
+  return dynamicTool({
+    description: request.description,
+    inputSchema: jsonSchema(request.inputSchema as JSONSchema7),
+    execute: request.execute,
+  });
+}
+
+export type CapabilityTool = Tool;

package/src/compaction/contracts.ts

@@ -0,0 +1,82 @@
+/**
+ * C6 compaction contracts: the data shapes the compaction service and task
+ * pipeline consume. The `CompactionPolicy` data interface keeps its exact
+ * pre-C6 identity; `core/compaction.ts` re-exports these types so the compat
+ * barrel, `core/agent.ts`, and every existing consumer keep working.
+ */
+
+import type { AssistantMessage, TextPart } from '@capekai/types';
+
+/** Compaction trigger reasons */
+export type CompactionTriggerReason = 'manual' | 'auto' | 'overflow';
+
+/**
+ * Compaction policy for configuring summary generation.
+ * All model/provider fields are optional - null means "use session/default".
+ * Pruning fields control which tool outputs get marked as compacted.
+ * Auto-threshold fields control the hybrid formula for pre-overflow compaction.
+ */
+export interface CompactionPolicy {
+  modelId: string | null;
+  providerId: string | null;
+  maxOutputTokens: number;
+  overflowThresholdRatio: number | null;
+  // WS4: Budget-aware pruning knobs
+  preserveRecentToolCount: number;
+  preserveSmallToolChars: number;
+  toolClearCharsThreshold: number;
+  maxPrunedToolCount: number;
+  // Hybrid formula for auto-compaction threshold
+  autoThresholdRatio: number;
+  autoReserveCapTokens: number;
+  autoSafetyMarginTokens: number;
+}
+
+/**
+ * Trigger created before compaction.
+ * The trigger is a user message with a standard CompactionPart.
+ */
+export interface CompactionTrigger {
+  messageId: string;
+  reason: CompactionTriggerReason;
+}
+
+/**
+ * Compaction task result
+ */
+export interface CompactionTaskResult {
+  trigger: CompactionTrigger;
+  summaryMessage: AssistantMessage;
+  textParts: TextPart[];
+  tokensUsed: {
+    prompt: number;
+    completion: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    noCache?: number;
+  };
+}
+
+/**
+ * A function that generates a summary from a prompt.
+ * Abstracts away model resolution and the generateText/streamText call.
+ */
+export interface GenerateSummaryFn {
+  (prompt: string, policy: CompactionPolicy, sessionId: string, abortSignal?: AbortSignal): Promise<{
+    text: string;
+    usage: {
+      prompt: number;
+      completion: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+      noCache?: number;
+    };
+    effectiveModelId: string;
+    effectiveProviderId: string;
+  }>;
+}
+
+export interface AutoThresholdResult {
+  threshold: number;
+  contextWindow: number | undefined;
+}

package/src/compaction/executor.ts

@@ -0,0 +1,161 @@
+/**
+ * C6 compaction executor. The pre-C6 module-global active-session set is
+ * replaced by scope-owned state: every guard and state transition resolves
+ * through `getCompactionService()`, so composed agent scopes hold isolated
+ * concurrency guards and unscoped consumers keep the process-default
+ * behavior.
+ */
+
+import { getModelsConfig } from '../configuration/runtime';
+import {
+  emitRuntimeEvent,
+  emitSessionUpdated,
+} from '../runtime/host-dependencies';
+import { getMessageWithParts, getSession, updateSession } from '../storage/runtime';
+import type { BroadcastFn, BroadcastSessionFn } from '../runtime/host';
+import type { CompactionTriggerReason, GenerateSummaryFn } from './contracts';
+import { getCompactionService } from './policy';
+import {
+  createCompactionTrigger,
+  persistCompactionFailure,
+  processCompactionTask,
+} from './task';
+
+export interface CompactionExecutorResult {
+  ok: true;
+  result: {
+    tokensUsed: {
+      prompt: number;
+      completion: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+      noCache?: number;
+    };
+    summaryMessageId: string;
+    textParts: Array<{ id: string; messageId: string; createdAt: number; type: string; text: string }>;
+  };
+  triggerMessageId: string;
+  reason: CompactionTriggerReason;
+}
+
+export interface CompactionExecutorError {
+  ok: false;
+  error: string;
+  triggerMessageId: string | null;
+  reason: CompactionTriggerReason;
+  skipped: boolean;
+}
+
+export function isCompactionActive(sessionId: string): boolean {
+  return getCompactionService().isCompactionActive(sessionId);
+}
+
+export async function executeCompaction(
+  sessionId: string,
+  reason: CompactionTriggerReason,
+  broadcast: BroadcastFn = emitRuntimeEvent,
+  broadcastSessUpdate: BroadcastSessionFn = emitSessionUpdated,
+  abortSignal?: AbortSignal,
+  /** Additive test/injection seam mirroring `processCompactionTask`'s own
+   * generateSummaryFn parameter. Production callers pass at most five
+   * arguments exactly like before; focused tests inject a deterministic
+   * summary generator to pin abort and failure behavior without a real
+   * model call. */
+  generateSummaryFn?: GenerateSummaryFn,
+): Promise<CompactionExecutorResult | CompactionExecutorError> {
+  const service = getCompactionService();
+  if (service.isCompactionActive(sessionId)) {
+    return {
+      ok: false,
+      error: 'Compaction is already in progress for this session',
+      triggerMessageId: null,
+      reason,
+      skipped: true,
+    };
+  }
+
+  let triggerMessageId: string | null = null;
+  const session = await getSession(sessionId);
+  if (!session || session.parentId) {
+    return {
+      ok: false,
+      error: 'Compaction is only available for main sessions',
+      triggerMessageId: null,
+      reason,
+      skipped: true,
+    };
+  }
+
+  // C6 step 6: mandatory concurrency gate backed by the persisted session
+  // flag. The flag is written by this executor and cleared by recovery, so
+  // a custom policy service whose in-memory guard is broken still cannot
+  // start a second compaction for the same session.
+  //
+  // Honest limitation (pre-existing, preserved): the persisted flag guards
+  // single-process exclusivity plus recovery. A second OS process writing
+  // the same database directly can still race the flag (check-then-set
+  // TOCTOU); SQLite locking is out of C6 scope.
+  if (session.compacting) {
+    return {
+      ok: false,
+      error: 'Compaction is already in progress for this session',
+      triggerMessageId: null,
+      reason,
+      skipped: true,
+    };
+  }
+
+  const config = getModelsConfig();
+  const policy = service.resolvePolicy(
+    session.selectedModel || config.defaultModel,
+    session.selectedProvider || config.defaultProvider,
+  );
+
+  service.beginCompaction(sessionId);
+  const compactingSession = await updateSession(sessionId, { compacting: true });
+  if (compactingSession) broadcastSessUpdate(compactingSession);
+
+  try {
+    const trigger = await createCompactionTrigger(sessionId, reason);
+    triggerMessageId = trigger.messageId;
+    const triggerMsg = await getMessageWithParts(trigger.messageId);
+    if (triggerMsg) {
+      broadcast({ kind: 'message', action: 'created', message: triggerMsg.message });
+      for (const part of triggerMsg.parts) broadcast({ kind: 'part', action: 'created', sessionId, part });
+    }
+
+    const result = await processCompactionTask(sessionId, trigger.messageId, policy, generateSummaryFn, abortSignal);
+    broadcast({ kind: 'message', action: 'created', message: result.summaryMessage });
+    for (const part of result.textParts) broadcast({ kind: 'part', action: 'created', sessionId, part });
+
+    const completedSession = await updateSession(sessionId, {
+      promptTokens: result.tokensUsed.prompt,
+      completionTokens: result.tokensUsed.completion,
+      totalTokens: result.tokensUsed.prompt + result.tokensUsed.completion,
+      cacheReadTokens: result.tokensUsed.cacheRead ?? 0,
+      cacheWriteTokens: result.tokensUsed.cacheWrite ?? 0,
+      noCacheTokens: result.tokensUsed.noCache ?? 0,
+      compacting: false,
+    });
+    if (completedSession) broadcastSessUpdate(completedSession);
+
+    return {
+      ok: true,
+      result: {
+        tokensUsed: result.tokensUsed,
+        summaryMessageId: result.summaryMessage.id,
+        textParts: result.textParts,
+      },
+      triggerMessageId,
+      reason,
+    };
+  } catch (err: unknown) {
+    const updatedSession = await updateSession(sessionId, { compacting: false });
+    if (updatedSession) broadcastSessUpdate(updatedSession);
+    const errorMessage = err instanceof Error ? err.message : 'Compaction failed';
+    if (triggerMessageId) await persistCompactionFailure(sessionId, triggerMessageId, errorMessage, broadcast);
+    return { ok: false, error: errorMessage, triggerMessageId, reason, skipped: false };
+  } finally {
+    service.endCompaction(sessionId);
+  }
+}