@rlynjb/aptkit-core 0.1.0

package/node_modules/@aptkit/runtime/dist/src/usage-ledger.d.ts

@@ -0,0 +1,29 @@
+import type { CapabilityEvent } from './events.js';
+export type TokenUsageSummary = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    modelName?: string;
+    turns: number;
+    estimated: boolean;
+};
+export type CostEstimate = {
+    currency: 'USD';
+    inputCost: number;
+    outputCost: number;
+    totalCost: number;
+    inputUsdPerMillion: number;
+    outputUsdPerMillion: number;
+    estimated: true;
+};
+export type UsagePricing = Pick<CostEstimate, 'inputUsdPerMillion' | 'outputUsdPerMillion'>;
+/** Sums model usage trace events into one provider-neutral usage ledger row. */
+export declare function summarizeUsage(trace: readonly CapabilityEvent[]): TokenUsageSummary;
+/** Counts model turns from a trace without requiring token fields to be present. */
+export declare function modelTurnCount(trace: readonly CapabilityEvent[]): number;
+/** Estimates USD cost from usage and known provider/model pricing. */
+export declare function estimateCost(provider: string, usage: Pick<TokenUsageSummary, 'inputTokens' | 'outputTokens'>, modelName: string): CostEstimate | undefined;
+/** Returns the currently configured per-million-token pricing for known model families. */
+export declare function pricingForModel(provider: string, modelName: string): UsagePricing | undefined;
+/** Formats estimated costs for compact Studio and replay-summary displays. */
+export declare function formatCost(costEstimate: CostEstimate | undefined): string;

package/node_modules/@aptkit/runtime/dist/src/usage-ledger.js

@@ -0,0 +1,61 @@
+/** Sums model usage trace events into one provider-neutral usage ledger row. */
+export function summarizeUsage(trace) {
+    return trace.reduce((summary, event) => {
+        if (event.type !== 'model_usage')
+            return summary;
+        const inputTokens = event.inputTokens ?? 0;
+        const outputTokens = event.outputTokens ?? 0;
+        return {
+            inputTokens: summary.inputTokens + inputTokens,
+            outputTokens: summary.outputTokens + outputTokens,
+            totalTokens: summary.totalTokens + inputTokens + outputTokens,
+            modelName: event.model || summary.modelName,
+            turns: summary.turns + 1,
+            estimated: summary.estimated || event.estimated === true,
+        };
+    }, { inputTokens: 0, outputTokens: 0, totalTokens: 0, modelName: '', turns: 0, estimated: false });
+}
+/** Counts model turns from a trace without requiring token fields to be present. */
+export function modelTurnCount(trace) {
+    return trace.filter((event) => event.type === 'model_usage').length;
+}
+/** Estimates USD cost from usage and known provider/model pricing. */
+export function estimateCost(provider, usage, modelName) {
+    const pricing = pricingForModel(provider, modelName);
+    if (!pricing)
+        return undefined;
+    const inputCost = (usage.inputTokens / 1_000_000) * pricing.inputUsdPerMillion;
+    const outputCost = (usage.outputTokens / 1_000_000) * pricing.outputUsdPerMillion;
+    return {
+        currency: 'USD',
+        inputCost,
+        outputCost,
+        totalCost: inputCost + outputCost,
+        inputUsdPerMillion: pricing.inputUsdPerMillion,
+        outputUsdPerMillion: pricing.outputUsdPerMillion,
+        estimated: true,
+    };
+}
+/** Returns the currently configured per-million-token pricing for known model families. */
+export function pricingForModel(provider, modelName) {
+    if (provider !== 'openai')
+        return undefined;
+    const normalized = modelName.toLowerCase();
+    if (normalized.startsWith('gpt-4.1-nano'))
+        return { inputUsdPerMillion: 0.1, outputUsdPerMillion: 0.4 };
+    if (normalized.startsWith('gpt-4.1-mini'))
+        return { inputUsdPerMillion: 0.4, outputUsdPerMillion: 1.6 };
+    if (normalized.startsWith('gpt-4.1'))
+        return { inputUsdPerMillion: 2, outputUsdPerMillion: 8 };
+    return undefined;
+}
+/** Formats estimated costs for compact Studio and replay-summary displays. */
+export function formatCost(costEstimate) {
+    if (!costEstimate)
+        return 'n/a';
+    if (costEstimate.totalCost === 0)
+        return '$0.00';
+    if (costEstimate.totalCost < 0.01)
+        return `$${costEstimate.totalCost.toFixed(4)}`;
+    return `$${costEstimate.totalCost.toFixed(2)}`;
+}

package/node_modules/@aptkit/runtime/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@aptkit/runtime",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/test/*.test.js"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/node_modules/@aptkit/tools/dist/src/coverage-gate.d.ts

@@ -0,0 +1,32 @@
+export type CapabilityDescriptorSource = {
+    events?: readonly {
+        name: string;
+        properties?: readonly string[];
+    }[];
+    catalogs?: readonly {
+        name: string;
+    }[];
+};
+export type CoverageLevel = 'full' | 'limited' | 'unavailable';
+export type CoverageRequirement = {
+    id: string;
+    label: string;
+    requires: readonly string[];
+    enriches?: readonly string[];
+};
+export type CoverageReportItem = {
+    category: string;
+    label: string;
+    coverage: CoverageLevel;
+    missing?: string[];
+};
+/** Builds capability tokens such as event names, event properties, and catalogs from a workspace-like descriptor. */
+export declare function schemaCapabilities(source: CapabilityDescriptorSource): Set<string>;
+/** Classifies whether a task can run completely, partially, or not at all from the available capabilities. */
+export declare function requirementCoverage(requirement: CoverageRequirement, capabilities: ReadonlySet<string>): CoverageLevel;
+/** Lists required or enriching capabilities that are absent for a task. */
+export declare function missingCapabilities(requirement: CoverageRequirement, capabilities: ReadonlySet<string>): string[];
+/** Produces an inspectable coverage report for Studio previews and pre-model gating. */
+export declare function coverageReport(requirements: readonly CoverageRequirement[], capabilities: ReadonlySet<string>): CoverageReportItem[];
+/** Filters out tasks that cannot run before the agent spends model tokens on them. */
+export declare function runnableRequirements<T extends CoverageRequirement>(requirements: readonly T[], capabilities: ReadonlySet<string>): T[];

package/node_modules/@aptkit/tools/dist/src/coverage-gate.js

@@ -0,0 +1,43 @@
+/** Builds capability tokens such as event names, event properties, and catalogs from a workspace-like descriptor. */
+export function schemaCapabilities(source) {
+    const capabilities = new Set();
+    for (const event of source.events ?? []) {
+        capabilities.add(event.name);
+        for (const property of event.properties ?? []) {
+            capabilities.add(`${event.name}.${property}`);
+        }
+    }
+    for (const catalog of source.catalogs ?? []) {
+        capabilities.add(`catalog:${catalog.name}`);
+    }
+    return capabilities;
+}
+/** Classifies whether a task can run completely, partially, or not at all from the available capabilities. */
+export function requirementCoverage(requirement, capabilities) {
+    if (!requirement.requires.every((dependency) => capabilities.has(dependency)))
+        return 'unavailable';
+    if (requirement.enriches?.length && !requirement.enriches.every((dependency) => capabilities.has(dependency)))
+        return 'limited';
+    return 'full';
+}
+/** Lists required or enriching capabilities that are absent for a task. */
+export function missingCapabilities(requirement, capabilities) {
+    return [...requirement.requires, ...(requirement.enriches ?? [])].filter((dependency) => !capabilities.has(dependency));
+}
+/** Produces an inspectable coverage report for Studio previews and pre-model gating. */
+export function coverageReport(requirements, capabilities) {
+    return requirements.map((requirement) => {
+        const coverage = requirementCoverage(requirement, capabilities);
+        const missing = missingCapabilities(requirement, capabilities);
+        return {
+            category: requirement.id,
+            label: requirement.label,
+            coverage,
+            ...(coverage !== 'full' && missing.length ? { missing } : {}),
+        };
+    });
+}
+/** Filters out tasks that cannot run before the agent spends model tokens on them. */
+export function runnableRequirements(requirements, capabilities) {
+    return requirements.filter((requirement) => requirementCoverage(requirement, capabilities) !== 'unavailable');
+}

package/node_modules/@aptkit/tools/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './coverage-gate.js';
+export * from './tool-registry.js';
+export * from './tool-policy.js';

package/node_modules/@aptkit/tools/dist/src/index.js

@@ -0,0 +1,3 @@
+export * from './coverage-gate.js';
+export * from './tool-registry.js';
+export * from './tool-policy.js';

package/node_modules/@aptkit/tools/dist/src/tool-policy.d.ts

@@ -0,0 +1,9 @@
+import type { ModelTool } from '@aptkit/runtime';
+import type { ToolDefinition } from './tool-registry.js';
+/** Capability-scoped allowlist that keeps agents from seeing tools outside their role. */
+export type ToolPolicy = {
+    capabilityId: string;
+    allowedTools: readonly string[];
+};
+/** Filters a registry catalog down to the provider-neutral tool schemas a model may call. */
+export declare function filterToolsForPolicy(allTools: readonly ToolDefinition[], policy: ToolPolicy): ModelTool[];

package/node_modules/@aptkit/tools/dist/src/tool-policy.js

@@ -0,0 +1,11 @@
+/** Filters a registry catalog down to the provider-neutral tool schemas a model may call. */
+export function filterToolsForPolicy(allTools, policy) {
+    const allowed = new Set(policy.allowedTools);
+    return allTools
+        .filter((tool) => allowed.has(tool.name))
+        .map((tool) => ({
+        name: tool.name,
+        description: tool.description ?? '',
+        inputSchema: tool.inputSchema,
+    }));
+}

package/node_modules/@aptkit/tools/dist/src/tool-registry.d.ts

@@ -0,0 +1,27 @@
+import type { ModelTool } from '@aptkit/runtime';
+export type ToolDefinition = ModelTool;
+/** Per-call controls passed from an agent loop into a tool implementation. */
+export type ToolCallOptions = {
+    signal?: AbortSignal;
+};
+/** Normalized result envelope for any model-callable tool. */
+export type ToolCallResult = {
+    result: unknown;
+    durationMs: number;
+};
+/** Provider-neutral registry that lists callable tools and executes them by name. */
+export type ToolRegistry = {
+    listTools(): Promise<ToolDefinition[]> | ToolDefinition[];
+    callTool(name: string, args: Record<string, unknown>, options?: ToolCallOptions): Promise<ToolCallResult>;
+};
+/** Function backing one tool in an in-memory or adapter-backed registry. */
+export type ToolHandler = (args: Record<string, unknown>, options?: ToolCallOptions) => Promise<unknown> | unknown;
+/** Test/demo registry that serves fixed tool definitions with injected handlers. */
+export declare class InMemoryToolRegistry implements ToolRegistry {
+    private readonly definitions;
+    private readonly handlers;
+    constructor(definitions: ToolDefinition[], handlers: Record<string, ToolHandler>);
+    listTools(): ToolDefinition[];
+    /** Executes a named handler and records wall-clock duration for traces. */
+    callTool(name: string, args: Record<string, unknown>, options?: ToolCallOptions): Promise<ToolCallResult>;
+}

package/node_modules/@aptkit/tools/dist/src/tool-registry.js

@@ -0,0 +1,25 @@
+/** Test/demo registry that serves fixed tool definitions with injected handlers. */
+export class InMemoryToolRegistry {
+    definitions;
+    handlers = new Map();
+    constructor(definitions, handlers) {
+        this.definitions = definitions;
+        for (const [name, handler] of Object.entries(handlers)) {
+            this.handlers.set(name, handler);
+        }
+    }
+    listTools() {
+        return this.definitions;
+    }
+    /** Executes a named handler and records wall-clock duration for traces. */
+    async callTool(name, args, options) {
+        options?.signal?.throwIfAborted();
+        const handler = this.handlers.get(name);
+        if (!handler) {
+            throw new Error(`tool not found: ${name}`);
+        }
+        const start = performance.now();
+        const result = await handler(args, options);
+        return { result, durationMs: Math.round(performance.now() - start) };
+    }
+}

package/node_modules/@aptkit/tools/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@aptkit/tools",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/test/*.test.js"
+  },
+  "dependencies": {
+    "@aptkit/runtime": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@rlynjb/aptkit-core",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Standalone AptKit core bundle for extracted agent capabilities.",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rlynjb/aptkit.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "README.md",
+    "dist/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/test/*.test.js"
+  },
+  "dependencies": {
+    "@aptkit/agent-anomaly-monitoring": "0.0.0",
+    "@aptkit/agent-diagnostic-investigation": "0.0.0",
+    "@aptkit/agent-query": "0.0.0",
+    "@aptkit/agent-recommendation": "0.0.0",
+    "@aptkit/context": "0.0.0",
+    "@aptkit/evals": "0.0.0",
+    "@aptkit/prompts": "0.0.0",
+    "@aptkit/runtime": "0.0.0",
+    "@aptkit/tools": "0.0.0"
+  },
+  "bundledDependencies": [
+    "@aptkit/agent-anomaly-monitoring",
+    "@aptkit/agent-diagnostic-investigation",
+    "@aptkit/agent-query",
+    "@aptkit/agent-recommendation",
+    "@aptkit/context",
+    "@aptkit/evals",
+    "@aptkit/prompts",
+    "@aptkit/runtime",
+    "@aptkit/tools"
+  ]
+}