@lensagent/core 0.1.0

package/dist/runtime/manifests.js

@@ -0,0 +1,117 @@
+import { digest } from '../core/codec.js';
+import { ADAPTER_CONTRACT_VERSIONS, PORT_CONTRACT_VERSIONS, fail } from '../core/domain.js';
+import { ConfigSchema } from '../config/schema.js';
+const platforms = Object.freeze(['windows-x64', 'linux-x64', 'darwin-x64', 'darwin-arm64']);
+const runtimes = Object.freeze(['node', 'bun']);
+export function adapterTarget(runtime) {
+    if (process.platform === 'win32' && process.arch === 'x64')
+        return { platform: 'windows-x64', runtime };
+    if (process.platform === 'linux' && process.arch === 'x64')
+        return { platform: 'linux-x64', runtime };
+    if (process.platform === 'darwin' && process.arch === 'x64')
+        return { platform: 'darwin-x64', runtime };
+    if (process.platform === 'darwin' && process.arch === 'arm64')
+        return { platform: 'darwin-arm64', runtime };
+    fail('ADAPTER_INCOMPATIBLE', 503, 'The current platform is not supported by Lens v1.');
+}
+export function capabilityManifest(definition, effectScopes = [definition.effect]) {
+    return createManifest({
+        id: `${definition.adapterId}:${definition.id}`,
+        portVersions: { capability: PORT_CONTRACT_VERSIONS.capability },
+        capabilities: [definition.id],
+        effectScopes,
+        configSchema: { input: definition.inputSchema, output: definition.outputSchema ?? null }
+    });
+}
+export function providerManifest(config, providerId) {
+    const provider = config.providers[providerId];
+    if (provider === undefined)
+        fail('ADAPTER_INCOMPATIBLE', 503, `Provider ${providerId} is not configured.`);
+    return createManifest({
+        id: `provider:${providerId}`,
+        portVersions: { model: PORT_CONTRACT_VERSIONS.model },
+        modelReferences: Object.keys(provider.models).sort().map((modelId) => `${providerId}/${modelId}`),
+        effectScopes: ['external'],
+        configSchema: ConfigSchema.properties.providers
+    });
+}
+export function coreManifests(config) {
+    return [
+        coreManifest('core.access', 'access', 'external', { listen: ConfigSchema.properties.listen, tls: ConfigSchema.properties.tls }),
+        coreManifest('core.config', 'config', 'workspace_write', ConfigSchema),
+        coreManifest('core.store', 'store', 'workspace_write', ConfigSchema.properties.database),
+        coreManifest('core.events', 'event', 'read_only', ConfigSchema.properties.sse),
+        coreManifest('core.execution', 'execution', 'full', ConfigSchema.properties.worker),
+        coreManifest('core.result', 'result', 'workspace_write', { version: 1 }),
+        coreManifest('core.tokenizer', 'tokenizer', 'read_only', ConfigSchema.properties.tokenizer),
+        coreManifest('core.observability', 'observability', 'read_only', ConfigSchema.properties.observability),
+        ...Object.keys(config.providers).sort().map((providerId) => providerManifest(config, providerId))
+    ];
+}
+export function assertCapabilityManifest(manifest, definition, target) {
+    assertManifest(manifest, target);
+    if (!manifest.capabilities.includes(definition.id) || !manifest.effectScopes.includes(definition.effect)) {
+        fail('ADAPTER_INCOMPATIBLE', 503, `Adapter manifest ${manifest.id} does not cover Capability ${definition.id}.`);
+    }
+}
+export function assertProviderManifest(manifest, reference, target) {
+    assertManifest(manifest, target);
+    if (!manifest.modelReferences.includes(reference) || !manifest.effectScopes.includes('external')) {
+        fail('ADAPTER_INCOMPATIBLE', 503, `Adapter manifest ${manifest.id} does not cover Model ${reference}.`);
+    }
+}
+export function assertManifestSet(manifests, target) {
+    const ids = new Set();
+    for (const manifest of manifests) {
+        assertManifest(manifest, target);
+        if (ids.has(manifest.id))
+            fail('ADAPTER_INCOMPATIBLE', 503, `Adapter manifest ${manifest.id} is duplicated.`);
+        ids.add(manifest.id);
+    }
+}
+export function manifestSetDigest(manifests, target) {
+    assertManifestSet(manifests, target);
+    return digest([...manifests].sort((left, right) => left.id.localeCompare(right.id)));
+}
+function coreManifest(id, port, effect, configSchema) {
+    return createManifest({ id, portVersions: { [port]: PORT_CONTRACT_VERSIONS[port] }, effectScopes: [effect], configSchema });
+}
+function createManifest(input) {
+    return Object.freeze({
+        id: input.id,
+        version: '1.0.0',
+        portVersions: Object.freeze({ ...input.portVersions }),
+        capabilities: Object.freeze([...(input.capabilities ?? [])]),
+        modelReferences: Object.freeze([...(input.modelReferences ?? [])]),
+        platforms,
+        runtimes,
+        effectScopes: Object.freeze([...input.effectScopes]),
+        concurrencyContractVersion: ADAPTER_CONTRACT_VERSIONS.concurrency,
+        errorContractVersion: ADAPTER_CONTRACT_VERSIONS.error,
+        cancellationContractVersion: ADAPTER_CONTRACT_VERSIONS.cancellation,
+        timeoutContractVersion: ADAPTER_CONTRACT_VERSIONS.timeout,
+        recoveryContractVersion: ADAPTER_CONTRACT_VERSIONS.recovery,
+        configSchemaDigest: `sha256:${digest(JSON.parse(JSON.stringify(input.configSchema)))}`,
+        conformanceTestVersion: ADAPTER_CONTRACT_VERSIONS.conformance
+    });
+}
+function assertManifest(manifest, target) {
+    const validContracts = manifest.concurrencyContractVersion === ADAPTER_CONTRACT_VERSIONS.concurrency
+        && manifest.errorContractVersion === ADAPTER_CONTRACT_VERSIONS.error
+        && manifest.cancellationContractVersion === ADAPTER_CONTRACT_VERSIONS.cancellation
+        && manifest.timeoutContractVersion === ADAPTER_CONTRACT_VERSIONS.timeout
+        && manifest.recoveryContractVersion === ADAPTER_CONTRACT_VERSIONS.recovery
+        && manifest.conformanceTestVersion === ADAPTER_CONTRACT_VERSIONS.conformance;
+    const validPorts = Object.entries(manifest.portVersions).length > 0
+        && Object.entries(manifest.portVersions).every(([port, version]) => PORT_CONTRACT_VERSIONS[port] === version);
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/.test(manifest.id)
+        || manifest.version.length === 0
+        || !validPorts
+        || !validContracts
+        || !manifest.platforms.includes(target.platform)
+        || !manifest.runtimes.includes(target.runtime)
+        || manifest.effectScopes.length === 0
+        || !/^sha256:[0-9a-f]{64}$/.test(manifest.configSchemaDigest)) {
+        fail('ADAPTER_INCOMPATIBLE', 503, `Adapter manifest ${manifest.id || '<unknown>'} is incompatible.`);
+    }
+}

package/dist/runtime/model.d.ts

@@ -0,0 +1,20 @@
+import { type ModelGateway, type ModelRequest, type ModelStreamEvent } from '../core/domain.js';
+import { type ConfigRuntime } from '../config/runtime.js';
+import type { HarnessConfig } from '../config/schema.js';
+import { type ResolvedProfile } from './profile.js';
+import { type AdapterTarget } from './manifests.js';
+export interface ResolvedModel {
+    readonly reference: string;
+    readonly contextWindowTokens: number;
+    readonly profile: ResolvedProfile;
+    readonly usageReliable: boolean;
+    readonly cacheSupported: boolean;
+    readonly programmaticToolCallingSupported: boolean;
+}
+export declare class AiModelGateway implements ModelGateway {
+    readonly config: ConfigRuntime;
+    readonly target: AdapterTarget;
+    constructor(config: ConfigRuntime, target: AdapterTarget);
+    resolve(reference: string, config?: HarnessConfig): ResolvedModel;
+    stream(request: ModelRequest, config?: HarnessConfig): AsyncIterable<ModelStreamEvent>;
+}

package/dist/runtime/model.js

@@ -0,0 +1,241 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { jsonSchema, stepCountIs, streamText, tool } from 'ai';
+import { jsonValue, toolArguments } from '../core/codec.js';
+import { fail } from '../core/domain.js';
+import { resolveSecret } from '../config/runtime.js';
+import { resolveProfile } from './profile.js';
+import { assertProviderManifest, providerManifest } from './manifests.js';
+export class AiModelGateway {
+    config;
+    target;
+    constructor(config, target) {
+        this.config = config;
+        this.target = target;
+    }
+    resolve(reference, config = this.config.current.config) {
+        const { providerId, modelId } = splitReference(reference);
+        const provider = config.providers[providerId];
+        const model = provider?.models[modelId];
+        if (provider === undefined || model === undefined)
+            fail('MODEL_NOT_FOUND', 404, `Model ${reference} is not configured.`);
+        assertProviderManifest(providerManifest(config, providerId), reference, this.target);
+        return {
+            reference,
+            contextWindowTokens: model.contextWindowTokens,
+            profile: resolveProfile(config, model.harnessProfile),
+            usageReliable: model.usageReliable ?? false,
+            cacheSupported: model.cacheSupported ?? false,
+            programmaticToolCallingSupported: model.programmaticToolCallingSupported ?? false
+        };
+    }
+    async *stream(request, config = this.config.current.config) {
+        const { providerId, modelId } = splitReference(request.model);
+        const providerConfig = config.providers[providerId];
+        const modelConfig = providerConfig?.models[modelId];
+        if (providerConfig === undefined || modelConfig === undefined)
+            fail('MODEL_NOT_FOUND', 404, `Model ${request.model} is not configured.`);
+        assertProviderManifest(providerManifest(config, providerId), request.model, this.target);
+        const resolved = createModel(providerId, modelConfig.wireModel ?? modelId, providerConfig);
+        const programmatic = request.programmaticToolCalling;
+        if (programmatic !== undefined && resolved.programmaticTool === undefined) {
+            fail('ADAPTER_INCOMPATIBLE', 503, 'The configured Provider Adapter does not support hosted Programmatic Tool Calling.');
+        }
+        const callers = new Map();
+        const ordinals = new Map();
+        const toolSet = tools(request.tools, programmatic, resolved.programmaticTool, callers, ordinals);
+        const instructions = request.messages.filter((message) => message.role === 'system').map((message) => message.content).join('\n\n');
+        const conversation = request.messages.filter((message) => message.role !== 'system');
+        const result = streamText({
+            model: resolved.model,
+            ...(instructions.length === 0 ? {} : { instructions }),
+            ...(conversation.length === 0 ? { prompt: '' } : { messages: conversation.map(aiMessage) }),
+            tools: toolSet,
+            ...(programmatic === undefined ? {} : {
+                experimental_toolCallers: Object.fromEntries(programmatic.capabilityIds
+                    .filter((capabilityId) => capabilityId !== 'programmatic_tool_run' && capabilityId !== 'capability_search')
+                    .map((capabilityId) => [capabilityId, ['programmatic_tool_run', 'AI_SDK_DIRECT_TOOL_CALL']])),
+                stopWhen: stepCountIs(programmatic.maxToolCalls + 1),
+                onToolExecutionStart: (event) => {
+                    const caller = providerCaller(event.toolCall.providerMetadata);
+                    if (caller.parentProviderCallId !== null)
+                        callers.set(event.toolCall.toolCallId, caller.parentProviderCallId);
+                }
+            }),
+            maxRetries: 0,
+            ...(request.maxOutputTokens === undefined ? {} : { maxOutputTokens: request.maxOutputTokens }),
+            abortSignal: request.signal,
+            ...(request.reasoningEffort === null ? {} : { providerOptions: reasoningOptions(providerId, providerConfig.adapter, request.reasoningEffort) })
+        });
+        let ordinal = 0;
+        for await (const part of result.stream) {
+            if (part.type === 'text-delta')
+                yield { type: 'text', text: part.text };
+            else if (part.type === 'reasoning-delta')
+                yield { type: 'thinking', text: part.text };
+            else if (part.type === 'tool-input-start') {
+                const toolOrdinal = ordinal++;
+                ordinals.set(part.id, toolOrdinal);
+                yield { type: 'toolStart', ordinal: toolOrdinal, id: part.id, name: part.toolName };
+            }
+            else if (part.type === 'tool-call') {
+                const toolOrdinal = ordinals.get(part.toolCallId) ?? ordinal++;
+                ordinals.set(part.toolCallId, toolOrdinal);
+                const caller = providerCaller(part.providerMetadata);
+                yield {
+                    type: 'tool',
+                    ordinal: toolOrdinal,
+                    id: part.toolCallId,
+                    name: part.toolName,
+                    // Not `jsonValue`: a Provider hands back a raw JSON string when the model calls a tool that was
+                    // not in the request's manifest, and storing that string poisons the Context permanently.
+                    arguments: toolArguments(part.input),
+                    ...(caller.parentProviderCallId === null ? {} : { parentProviderCallId: caller.parentProviderCallId }),
+                    ...(part.providerExecuted === true ? { providerExecuted: true } : {}),
+                    ...(caller.programmatic ? { programmaticCaller: true } : {})
+                };
+            }
+            else if (part.type === 'tool-result') {
+                const toolOrdinal = ordinals.get(part.toolCallId) ?? ordinal++;
+                ordinals.set(part.toolCallId, toolOrdinal);
+                yield {
+                    type: 'toolResult',
+                    ordinal: toolOrdinal,
+                    id: part.toolCallId,
+                    name: part.toolName,
+                    output: jsonValue(part.output),
+                    ...(part.providerExecuted === true ? { providerExecuted: true } : {})
+                };
+            }
+            else if (part.type === 'finish') {
+                yield {
+                    type: 'usage',
+                    inputTokens: part.totalUsage.inputTokens ?? 0,
+                    outputTokens: part.totalUsage.outputTokens ?? 0
+                };
+                yield { type: 'end', reason: part.finishReason };
+            }
+            else if (part.type === 'error') {
+                throw part.error;
+            }
+            else if (part.type === 'abort') {
+                throw new Error(part.reason ?? 'Model request aborted.');
+            }
+        }
+    }
+}
+function reasoningOptions(providerId, adapter, effort) {
+    if (adapter === '@ai-sdk/openai')
+        return { openai: { reasoningEffort: effort } };
+    if (adapter === '@ai-sdk/anthropic')
+        return { anthropic: { effort } };
+    return { [providerId]: { reasoningEffort: effort } };
+}
+function createModel(providerId, modelId, config) {
+    const apiKey = resolveSecret(config.options.apiKey);
+    if (config.adapter === '@ai-sdk/openai') {
+        const provider = createOpenAI({ ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.baseURL === undefined ? {} : { baseURL: config.options.baseURL }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }) });
+        return { model: provider(modelId), programmaticTool: provider.tools.programmaticToolCalling() };
+    }
+    if (config.adapter === '@ai-sdk/anthropic') {
+        return { model: createAnthropic({ ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.baseURL === undefined ? {} : { baseURL: config.options.baseURL }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }) })(modelId) };
+    }
+    if (config.options.baseURL === undefined)
+        fail('CONFIG_INVALID', 503, `Provider ${providerId} requires options.baseURL.`);
+    return { model: createOpenAICompatible({ name: providerId, baseURL: config.options.baseURL, ...(apiKey === undefined ? {} : { apiKey }), ...(config.options.headers === undefined ? {} : { headers: config.options.headers }) })(modelId) };
+}
+function tools(definitions, programmatic, providerTool, callers, ordinals) {
+    const result = {};
+    for (const definition of definitions) {
+        if (definition.id === 'programmatic_tool_run')
+            continue;
+        const eligible = programmatic?.capabilityIds.includes(definition.id) === true;
+        const descriptor = {
+            description: definition.description,
+            inputSchema: jsonSchema(definition.inputSchema),
+            outputSchema: jsonSchema((definition.outputSchema ?? { type: 'object', additionalProperties: true }))
+        };
+        if (eligible) {
+            result[definition.id] = tool({
+                ...descriptor,
+                providerOptions: { openai: { outputSchema: definition.outputSchema ?? { type: 'object', additionalProperties: true } } },
+                execute: (input, options) => {
+                    const parentProviderCallId = callers.get(options.toolCallId);
+                    return programmatic.execute({
+                        capabilityId: definition.id,
+                        arguments: jsonValue(input),
+                        providerCallId: options.toolCallId,
+                        ordinal: ordinals.get(options.toolCallId) ?? 0,
+                        ...(parentProviderCallId === undefined ? {} : { parentProviderCallId })
+                    }, options.abortSignal);
+                }
+            });
+        }
+        else {
+            result[definition.id] = tool(descriptor);
+        }
+    }
+    if (programmatic !== undefined && providerTool !== undefined)
+        result.programmatic_tool_run = providerTool;
+    return result;
+}
+function providerCaller(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return { programmatic: false, parentProviderCallId: null };
+    const candidates = [value, ...Object.values(value).filter(isObject)];
+    for (const candidate of candidates) {
+        const caller = candidate.caller;
+        if (!isObject(caller) || caller.type !== 'program')
+            continue;
+        const id = caller.callerId ?? caller.caller_id ?? caller.toolId ?? caller.tool_id;
+        return { programmatic: true, parentProviderCallId: typeof id === 'string' && id.length > 0 ? id : null };
+    }
+    return { programmatic: false, parentProviderCallId: null };
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function aiMessage(message) {
+    if (message.role === 'assistant' && message.toolCalls !== undefined) {
+        return {
+            role: 'assistant',
+            content: [
+                ...(message.content.length === 0 ? [] : [{ type: 'text', text: message.content }]),
+                ...message.toolCalls.map((call) => ({
+                    type: 'tool-call',
+                    toolCallId: call.id,
+                    toolName: call.name,
+                    input: call.arguments
+                }))
+            ]
+        };
+    }
+    if (message.role === 'tool') {
+        return {
+            role: 'tool',
+            content: [{
+                    type: 'tool-result',
+                    toolCallId: message.toolCallId ?? 'unknown',
+                    toolName: message.toolName ?? 'unknown',
+                    output: toolOutput(message.content)
+                }]
+        };
+    }
+    return { role: message.role, content: message.content };
+}
+function toolOutput(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return { type: 'json', value: jsonValue(parsed) };
+    }
+    catch {
+        return { type: 'text', value: content };
+    }
+}
+function splitReference(reference) {
+    const slash = reference.indexOf('/');
+    if (slash < 1 || slash === reference.length - 1)
+        fail('MODEL_REFERENCE_INVALID', 400, 'Model Reference must use provider/model.');
+    return { providerId: reference.slice(0, slash), modelId: reference.slice(slash + 1) };
+}

package/dist/runtime/observability.d.ts

@@ -0,0 +1,22 @@
+import type { Json } from '../core/domain.js';
+import type { HarnessConfig } from '../config/schema.js';
+export interface RuntimeRecord {
+    readonly sequence: number;
+    readonly occurred_at: string;
+    readonly component: string;
+    readonly operation: string;
+    readonly outcome: string;
+    readonly duration_ms: number;
+    readonly fields: Readonly<Record<string, Json>>;
+}
+export declare class Observability {
+    #private;
+    constructor(root: string, config: HarnessConfig['observability']);
+    record(component: string, operation: string, outcome: string, durationMs: number, fields?: Readonly<Record<string, Json>>): void;
+    increment(name: string, amount?: number): void;
+    logs(limit: number): readonly RuntimeRecord[];
+    traces(limit: number): readonly RuntimeRecord[];
+    agentOps(limit: number): readonly RuntimeRecord[];
+    metrics(): string;
+    close(): Promise<void>;
+}

package/dist/runtime/observability.js

@@ -0,0 +1,104 @@
+import { appendFile, mkdir, readdir, rename, stat, unlink } from 'node:fs/promises';
+import { basename, dirname, resolve } from 'node:path';
+import { now } from '../core/codec.js';
+export class Observability {
+    #logs = [];
+    #traces = [];
+    #agentOps = [];
+    #metrics = new Map();
+    #capacity;
+    #root;
+    #logConfig;
+    #sequence = 0;
+    #writeTail = Promise.resolve();
+    #retentionChecked = false;
+    constructor(root, config) {
+        this.#root = root;
+        this.#capacity = config?.traces?.capacity ?? 2048;
+        this.#logConfig = config?.logs;
+    }
+    record(component, operation, outcome, durationMs, fields = {}) {
+        const record = {
+            sequence: ++this.#sequence,
+            occurred_at: now(),
+            component,
+            operation,
+            outcome,
+            duration_ms: durationMs,
+            fields
+        };
+        this.#push(this.#logs, record);
+        this.#push(this.#traces, record);
+        if (component === 'agent' || component === 'call')
+            this.#push(this.#agentOps, record);
+        this.increment(`${component}_${operation}_${outcome}`);
+        if (this.#logConfig?.enabled === true) {
+            this.#writeTail = this.#writeTail.then(() => this.#write(record)).catch(() => undefined);
+        }
+    }
+    increment(name, amount = 1) {
+        this.#metrics.set(metricName(name), (this.#metrics.get(metricName(name)) ?? 0) + amount);
+    }
+    logs(limit) {
+        return this.#logs.slice(-limit);
+    }
+    traces(limit) {
+        return this.#traces.slice(-limit);
+    }
+    agentOps(limit) {
+        return this.#agentOps.slice(-limit);
+    }
+    metrics() {
+        return [...this.#metrics.entries()].sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, value]) => `# TYPE lens_${name} counter\nlens_${name} ${value}`)
+            .join('\n') + '\n';
+    }
+    async close() {
+        await this.#writeTail;
+    }
+    #push(target, record) {
+        target.push(record);
+        if (target.length > this.#capacity)
+            target.splice(0, target.length - this.#capacity);
+    }
+    async #write(record) {
+        const config = this.#logConfig;
+        if (config === undefined)
+            return;
+        const path = resolve(this.#root, config.path);
+        await mkdir(dirname(path), { recursive: true });
+        if (!this.#retentionChecked) {
+            this.#retentionChecked = true;
+            await pruneLogs(path, config.retentionDays);
+        }
+        const size = await stat(path).then((entry) => entry.size, () => 0);
+        if (size >= config.maxFileBytes) {
+            if (config.maxFiles === 1)
+                await unlink(path).catch(() => undefined);
+            else
+                await unlink(`${path}.${config.maxFiles - 1}`).catch(() => undefined);
+            for (let index = config.maxFiles - 2; index >= 1; index -= 1) {
+                await rename(`${path}.${index}`, `${path}.${index + 1}`).catch(() => undefined);
+            }
+            if (config.maxFiles > 1)
+                await rename(path, `${path}.1`).catch(() => undefined);
+        }
+        await appendFile(path, `${JSON.stringify(record)}\n`, 'utf8');
+    }
+}
+async function pruneLogs(path, retentionDays) {
+    const threshold = Date.now() - retentionDays * 86400000;
+    const directory = dirname(path);
+    const name = basename(path);
+    for (const entry of await readdir(directory).catch(() => [])) {
+        if (entry !== name && !entry.startsWith(`${name}.`))
+            continue;
+        const candidate = resolve(directory, entry);
+        const modified = await stat(candidate).then((value) => value.mtimeMs, () => Date.now());
+        if (modified < threshold)
+            await unlink(candidate).catch(() => undefined);
+    }
+}
+function metricName(value) {
+    return value.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+}

package/dist/runtime/policy.d.ts

@@ -0,0 +1,8 @@
+import { type EffectScope, type Json, type Policy } from '../core/domain.js';
+export interface PolicyDecision {
+    readonly state: 'WAITING' | 'QUEUED';
+    readonly waitReason?: 'user_input' | 'policy_review';
+    readonly autoReview: boolean;
+}
+export declare function decidePolicy(policy: Policy, effect: EffectScope): PolicyDecision;
+export declare function policyPrompt(capabilityId: string): Json;

package/dist/runtime/policy.js

@@ -0,0 +1,31 @@
+import { fail } from '../core/domain.js';
+export function decidePolicy(policy, effect) {
+    if (policy === 'ask')
+        return { state: 'WAITING', waitReason: 'user_input', autoReview: false };
+    if (policy === 'auto_approve')
+        return { state: 'WAITING', waitReason: 'policy_review', autoReview: true };
+    if (policy === 'full_access')
+        return { state: 'QUEUED', autoReview: false };
+    if (rank(effect) <= rank(policyEffect(policy)))
+        return { state: 'QUEUED', autoReview: false };
+    fail('POLICY_DENIED', 403, `Policy ${policy} does not allow effect ${effect}.`);
+}
+export function policyPrompt(capabilityId) {
+    return {
+        kind: 'policy_approval',
+        question: `Approve the Capability call ${capabilityId}?`,
+        options: [{ label: 'Approve', value: 'approve' }, { label: 'Reject', value: 'reject' }],
+        allow_freeform: false,
+        multi_select: false
+    };
+}
+function policyEffect(policy) {
+    if (policy === 'read_only')
+        return 'read_only';
+    if (policy === 'workspace_write')
+        return 'workspace_write';
+    return 'external';
+}
+function rank(effect) {
+    return ['read_only', 'workspace_write', 'external', 'full'].indexOf(effect);
+}

package/dist/runtime/profile.d.ts

@@ -0,0 +1,8 @@
+import type { HarnessConfig, ModelHarnessProfile } from '../config/schema.js';
+export interface ResolvedProfile {
+    readonly id: string;
+    readonly digest: string;
+    readonly value: ModelHarnessProfile;
+}
+export declare function resolveProfile(config: HarnessConfig, id?: string): ResolvedProfile;
+export declare function resolveReasoningEffort(profile: ResolvedProfile, configured: string | null): string;

package/dist/runtime/profile.js

@@ -0,0 +1,52 @@
+import { digest } from '../core/codec.js';
+import { fail } from '../core/domain.js';
+const genericProfile = {
+    version: 1,
+    systemPrompt: {
+        sourceVersion: 'lens-agent-v1',
+        content: 'You are a Lens Agent. Complete the user goal and use only the supplied capabilities.',
+        container: 'system'
+    },
+    context: {
+        segmentOrder: ['system', 'context', 'tools'],
+        preserveProviderVisibleOrder: true,
+        allowExternalTransforms: false
+    },
+    semantics: {
+        reasoningStateRoundTrip: 'optional',
+        thinkingContinuation: 'optional',
+        toolResultOrder: 'call_ordinal',
+        structuredOutput: 'supported',
+        toolDescriptionStyle: 'plain',
+        recoveryConstraints: { partialResponseResume: 'forbidden', preserveReasoningState: false }
+    },
+    ptc: {
+        enabledByDefault: false,
+        maxToolCalls: 32,
+        schemaVersion: 'programmatic-tool-run-v1',
+        instruction: 'Run bounded tool-heavy work through the hosted programmatic tool runtime. Use only the capability IDs frozen in this request.'
+    },
+    effort: { allowed: ['none', 'minimal', 'low', 'medium', 'high'], default: 'medium' },
+    cache: {
+        enabledByDefault: false,
+        minimumEligiblePrefixTokens: 1024,
+        maximumBreakpoints: 4,
+        segmentStability: { system: 'stable', context: 'dynamic', tools: 'stable' }
+    }
+};
+export function resolveProfile(config, id = 'generic-v1') {
+    const value = id === 'generic-v1' ? genericProfile : config.modelHarnessProfiles?.[id];
+    if (value === undefined)
+        fail('MODEL_PROFILE_NOT_FOUND', 503, `Model Harness Profile ${id} is not configured.`);
+    if (!value.effort.allowed.includes(value.effort.default)) {
+        fail('MODEL_PROFILE_INVALID', 503, `Model Harness Profile ${id} has an invalid default reasoning effort.`);
+    }
+    return { id, digest: digest(value), value };
+}
+export function resolveReasoningEffort(profile, configured) {
+    const effort = configured ?? profile.value.effort.default;
+    if (!profile.value.effort.allowed.includes(effort)) {
+        fail('MODEL_EFFORT_UNSUPPORTED', 400, `Reasoning effort ${effort} is not supported by Model Harness Profile ${profile.id}.`);
+    }
+    return effort;
+}

package/dist/runtime/projects.d.ts

@@ -0,0 +1,40 @@
+import type { ConfigRuntime } from '../config/runtime.js';
+import type { Store } from '../store/store.js';
+import type { ArtifactStore } from './artifacts.js';
+import type { RegisteredCapability } from './capabilities.js';
+import { CapabilityRegistry } from './capabilities.js';
+import type { Scheduler } from './scheduler.js';
+import type { AiModelGateway } from './model.js';
+import type { AutoReviewer } from './review.js';
+import { CallRuntime } from './calls.js';
+import { ContextEngine } from './context.js';
+import { AgentRuntime } from './agent.js';
+import { type AdapterTarget } from './manifests.js';
+import type { EventBus } from './events.js';
+export interface ProjectRuntime {
+    readonly projectId: string;
+    readonly registry: CapabilityRegistry;
+    readonly calls: CallRuntime;
+    readonly context: ContextEngine;
+    readonly agents: AgentRuntime;
+    contractDigest(): string;
+    refreshSkills(): void;
+}
+export declare class ProjectRuntimes {
+    #private;
+    readonly store: Store;
+    readonly config: ConfigRuntime;
+    readonly scheduler: Scheduler;
+    readonly artifacts: ArtifactStore;
+    readonly models: AiModelGateway;
+    readonly reviewer: AutoReviewer;
+    readonly sharedCapabilities: readonly RegisteredCapability[];
+    readonly target: AdapterTarget;
+    readonly events: EventBus;
+    readonly pinnedProjectId: string;
+    constructor(store: Store, config: ConfigRuntime, scheduler: Scheduler, artifacts: ArtifactStore, models: AiModelGateway, reviewer: AutoReviewer, sharedCapabilities: readonly RegisteredCapability[], target: AdapterTarget, events: EventBus, pinnedProjectId: string);
+    get(projectId: string): ProjectRuntime;
+    refresh(projectId: string): void;
+    startIdleEviction(maxIdleMs?: number): void;
+    close(): Promise<void>;
+}