@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/dist/src/provider-payload.js

@@ -0,0 +1,264 @@
+import { getCurrentTools } from '@earendil-works/pi-ai';
+import { canonical, object } from './protocol.js';
+import { getProviderModel, validateClaudePayload } from './provider-config.js';
+const common = ['model', 'stream', 'tools', 'tool_choice', 'temperature', 'top_p', 'metadata'];
+const allowedFields = {
+    'anthropic-messages': [
+        ...common,
+        'messages',
+        'system',
+        'max_tokens',
+        'betas',
+        'thinking',
+        'output_config',
+        'top_k',
+        'stop_sequences',
+    ],
+    'openai-completions': [
+        ...common,
+        'messages',
+        'max_tokens',
+        'max_completion_tokens',
+        'store',
+        'stream_options',
+        'reasoning',
+        'reasoning_effort',
+        'thinking',
+        'chat_template_args',
+        'enable_thinking',
+        'tool_stream',
+        'prompt_cache_key',
+        'prompt_cache_retention',
+        'frequency_penalty',
+        'presence_penalty',
+        'repetition_penalty',
+        'min_p',
+        'top_k',
+        'stop',
+    ],
+    'mistral-conversations': [
+        ...common,
+        'messages',
+        'maxTokens',
+        'max_tokens',
+        'toolChoice',
+        'reasoningEffort',
+        'reasoning_effort',
+        'promptMode',
+        'prompt_mode',
+        'promptCacheKey',
+        'prompt_cache_key',
+    ],
+    'openai-responses': [
+        ...common,
+        'input',
+        'store',
+        'max_output_tokens',
+        'include',
+        'reasoning',
+        'prompt_cache_key',
+        'prompt_cache_options',
+        'prompt_cache_retention',
+        'service_tier',
+        'text',
+        'parallel_tool_calls',
+        'instructions',
+    ],
+    'azure-openai-responses': [
+        ...common,
+        'input',
+        'store',
+        'max_output_tokens',
+        'include',
+        'reasoning',
+        'prompt_cache_key',
+        'service_tier',
+        'text',
+        'parallel_tool_calls',
+    ],
+    'openai-codex-responses': [
+        ...common,
+        'input',
+        'store',
+        'include',
+        'reasoning',
+        'prompt_cache_key',
+        'service_tier',
+        'text',
+        'parallel_tool_calls',
+        'instructions',
+    ],
+    'google-generative-ai': ['model', 'contents', 'config'],
+    'google-vertex': ['model', 'contents', 'config'],
+    'bedrock-converse-stream': [
+        'modelId',
+        'messages',
+        'system',
+        'inferenceConfig',
+        'toolConfig',
+        'additionalModelRequestFields',
+        'requestMetadata',
+    ],
+    'pi-messages': ['model', 'context', 'options'],
+};
+function keys(value, allowed) {
+    if (Object.keys(value).some((key) => !allowed.includes(key) && value[key] !== undefined))
+        throw new Error('Unsupported provider execution feature');
+}
+function cap(value, route) {
+    if (!Number.isSafeInteger(value) || Number(value) < 1 || Number(value) > route.max_tokens)
+        throw new Error('Unapproved provider output limit');
+}
+function inventory(values, names, kind) {
+    if (!Array.isArray(values))
+        throw new Error('Provider tool inventory missing');
+    const actual = [];
+    for (const value of values) {
+        const tool = object(value);
+        if (kind === 'google') {
+            if (Object.keys(tool).some((key) => key !== 'functionDeclarations') ||
+                !Array.isArray(tool.functionDeclarations))
+                throw new Error('Provider server tools disabled');
+            actual.push(...tool.functionDeclarations.map((entry) => String(object(entry).name)));
+        }
+        else if (kind === 'bedrock') {
+            if (Object.keys(tool).some((key) => key !== 'toolSpec'))
+                throw new Error('Provider server tools disabled');
+            actual.push(String(object(tool.toolSpec).name));
+        }
+        else if (kind === 'function') {
+            if (tool.type !== 'function')
+                throw new Error('Provider server tools disabled');
+            actual.push(String(tool.name ?? object(tool.function).name));
+        }
+        else
+            actual.push(String(tool.name));
+    }
+    if (canonical(actual.sort()) !== canonical([...names].sort()))
+        throw new Error('Unapproved provider tool inventory');
+}
+function lastText(messages, frame, parts, role = 'user') {
+    if (!Array.isArray(messages) || !messages.length)
+        throw new Error('Provider messages missing');
+    const last = object(messages.at(-1));
+    const content = last[parts];
+    const blocks = Array.isArray(content)
+        ? content.filter((block) => !(Object.keys(object(block)).length === 1 && object(block).cachePoint))
+        : [];
+    const text = typeof content === 'string' ? content : blocks.length ? object(blocks.at(-1)).text : undefined;
+    if (last.role !== role || text !== frame)
+        throw new Error('Required task context missing from provider payload');
+}
+/** Validate the API-specific payload after extension hooks. No hosted tools or hidden continuations. */
+export function validateProviderPayload(value, route, frame, tools, allowUncapped = false) {
+    const p = object(value), api = getProviderModel(route)?.api;
+    keys(p, allowedFields[String(api)] ?? []);
+    for (const key of [
+        'fallbacks',
+        'fallback_models',
+        'models',
+        'route',
+        'mcp_servers',
+        'container',
+        'context_management',
+        'previous_response_id',
+        'conversation',
+        'background',
+        'environment',
+        'agents',
+        'built_in_tools',
+        'cachedContent',
+    ])
+        if (p[key] !== undefined && p[key] !== false)
+            throw new Error('Unsupported provider execution feature');
+    const deployment = route.provider === 'azure'
+        ? (route.connection?.configuration.AZURE_OPENAI_DEPLOYMENT_NAME_MAP?.split(',')
+            .map((entry) => entry.trim().split('='))
+            .find(([id]) => id === route.model)?.[1]
+            ?.trim() ?? route.model)
+        : route.model;
+    if (api === 'anthropic-messages')
+        return validateClaudePayload(p, route, frame, tools);
+    if (api === 'google-generative-ai' || api === 'google-vertex') {
+        if (p.model !== deployment)
+            throw new Error('Unapproved provider model');
+        const config = object(p.config);
+        keys(config, [
+            'maxOutputTokens',
+            'temperature',
+            'topP',
+            'topK',
+            'systemInstruction',
+            'tools',
+            'toolConfig',
+            'thinkingConfig',
+            'abortSignal',
+            'httpOptions',
+        ]);
+        if (config.httpOptions !== undefined &&
+            canonical(config.httpOptions) !==
+                canonical({ retryOptions: { attempts: 1 }, timeout: 120000 }))
+            throw new Error('Unapproved Google HTTP controls');
+        for (const key of ['cachedContent', 'automaticFunctionCalling', 'responseModalities'])
+            if (config[key] !== undefined)
+                throw new Error('Unsupported Google execution feature');
+        cap(config.maxOutputTokens, route);
+        lastText(p.contents, frame, 'parts');
+        inventory(config.tools ?? [], tools, 'google');
+    }
+    else if (api === 'bedrock-converse-stream') {
+        if (p.modelId !== route.model)
+            throw new Error('Unapproved provider model');
+        keys(object(p.inferenceConfig), ['maxTokens', 'temperature', 'topP', 'stopSequences']);
+        keys(object(p.additionalModelRequestFields ?? {}), [
+            'thinking',
+            'reasoningConfig',
+            'reasoning_effort',
+            'reasoning',
+            'output_config',
+            'anthropic_beta',
+        ]);
+        cap(object(p.inferenceConfig).maxTokens, route);
+        lastText(p.messages, frame, 'content');
+        inventory(object(p.toolConfig).tools ?? [], tools, 'bedrock');
+        if (p.guardrailConfig || p.promptVariables || p.performanceConfig)
+            throw new Error('Unsupported Bedrock execution feature');
+    }
+    else if (api === 'pi-messages') {
+        if (p.model !== deployment)
+            throw new Error('Unapproved provider model');
+        keys(object(p.options), [
+            'temperature',
+            'maxTokens',
+            'reasoning',
+            'cacheRetention',
+            'sessionId',
+            'toolChoice',
+        ]);
+        cap(object(p.options).maxTokens, route);
+        const context = object(p.context);
+        lastText(context.messages, frame, 'content');
+        inventory(getCurrentTools(context.messages), tools, 'pi');
+    }
+    else if (['openai-responses', 'azure-openai-responses', 'openai-codex-responses'].includes(String(api))) {
+        if (p.model !== deployment)
+            throw new Error('Unapproved provider model');
+        if (p.stream !== true)
+            throw new Error('Provider streaming required');
+        if (!allowUncapped || p.max_output_tokens !== undefined)
+            cap(p.max_output_tokens, route);
+        lastText(p.input, frame, 'content');
+        inventory(p.tools ?? [], tools, 'function');
+        if (p.store !== false)
+            throw new Error('Provider storage disabled');
+    }
+    else if (api === 'openai-completions' || api === 'mistral-conversations') {
+        if (p.model !== deployment || p.stream !== true)
+            throw new Error('Unapproved provider model');
+        cap(p.max_completion_tokens ?? p.max_tokens ?? p.maxTokens, route);
+        lastText(p.messages, frame, 'content');
+        inventory(p.tools ?? [], tools, 'function');
+    }
+    else
+        throw new Error('Unsupported provider chat API');
+}

package/dist/src/provider-transport.js

@@ -0,0 +1,36 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { BedrockRuntimeClient } from '@aws-sdk/client-bedrock-runtime';
+const scope = new AsyncLocalStorage();
+let installed = false;
+let underlyingFetch;
+/** Worker-local SDK interception, scoped to the active model call (not auth refresh). */
+export function installProviderTransport() {
+    if (installed)
+        return underlyingFetch;
+    installed = true;
+    const originalFetch = (underlyingFetch = globalThis.fetch);
+    globalThis.fetch = (input, init) => scope.getStore()?.fetch(input, init) ??
+        Promise.reject(new Error('Unadmitted worker network request'));
+    const send = BedrockRuntimeClient.prototype.send;
+    BedrockRuntimeClient.prototype.send = function (...args) {
+        const gate = scope.getStore();
+        if (gate) {
+            // Pi 1.3.0 doesn't forward maxRetries to this SDK. Disable SDK retries explicitly.
+            this.config.retryStrategy = async () => ({
+                mode: 'standard',
+                retry: async (next, request) => next(request),
+            });
+            const handler = this.config.requestHandler;
+            const handle = handler.handle.bind(handler);
+            handler.handle = async (request, options) => {
+                await gate.bedrock(request);
+                return handle(request, options);
+            };
+        }
+        return Reflect.apply(send, this, args);
+    };
+    return originalFetch;
+}
+export function withProviderTransport(transport, fn) {
+    return scope.run(transport, fn);
+}

package/dist/src/provider-usage.js

@@ -0,0 +1,59 @@
+function record(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+const token = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+/** A normalized zero is not evidence that a provider reported zero usage. */
+export class ProviderUsageReceipt {
+    input = false;
+    output = false;
+    observe(api, value) {
+        const event = record(value);
+        let input, output;
+        switch (api) {
+            case 'anthropic-messages': {
+                const usage = record(event.type === 'message_start' ? record(event.message).usage : event.usage);
+                input = usage.input_tokens;
+                output = event.type === 'message_delta' ? usage.output_tokens : undefined;
+                break;
+            }
+            case 'google-generative-ai':
+            case 'google-vertex': {
+                const usage = record(event.usageMetadata);
+                input = usage.promptTokenCount;
+                output = usage.candidatesTokenCount;
+                break;
+            }
+            case 'bedrock-converse-stream': {
+                const usage = record(record(event.metadata).usage);
+                input = usage.inputTokens;
+                output = usage.outputTokens;
+                break;
+            }
+            case 'openai-responses':
+            case 'azure-openai-responses':
+            case 'openai-codex-responses': {
+                const usage = record(record(event.response).usage);
+                input = usage.input_tokens;
+                output = usage.output_tokens;
+                break;
+            }
+            case 'pi-messages': {
+                const usage = record(event.usage);
+                input = usage.input;
+                output = usage.output;
+                break;
+            }
+            default: {
+                const usage = record(event.usage);
+                input = usage.prompt_tokens ?? usage.promptTokens;
+                output = usage.completion_tokens ?? usage.completionTokens;
+                break;
+            }
+        }
+        this.input ||= token(input);
+        this.output ||= token(output);
+    }
+    get complete() {
+        return this.input && this.output;
+    }
+}

package/dist/src/repository-snapshots.js

@@ -0,0 +1,219 @@
+import { digest, integer, ServiceError, string } from './protocol.js';
+import { readTree, filePath } from './workspaces.js';
+import { workspaceDiff } from './workspace-diff.js';
+export function repositoryPath(value) {
+    const path = filePath(value);
+    if (path
+        .split('/')
+        .some((part) => /^(?:\.env(?:\..*)?|\.npmrc|\.netrc|\.aws|\.ssh|\.codex|\.gemini|\.claude|\.mcp\.json|\.salaam|\.pi|\.agents|\.state|credentials)$/i.test(part)))
+        throw new ServiceError('unsafe_path', 'Credential and control files are outside specialist scope');
+    return path;
+}
+export function repositoryTree(tree) {
+    return Object.fromEntries(Object.entries(tree).filter(([path]) => {
+        try {
+            repositoryPath(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }));
+}
+export class RepositorySnapshots {
+    store;
+    artifacts;
+    workspaces;
+    constructor(store, artifacts, workspaces) {
+        this.store = store;
+        this.artifacts = artifacts;
+        this.workspaces = workspaces;
+    }
+    /** Caller commits these references with the child intent. No live mount is handed to a reader. */
+    capture(parent, child) {
+        const workspace = this.workspaces.verify(parent), tree = repositoryTree(readTree(workspace.root));
+        if (digest(readTree(workspace.root)) !== workspace.digest)
+            throw new ServiceError('workspace_changed', 'Workspace changed during specialist admission');
+        const base = repositoryTree(JSON.parse(this.artifacts.read(workspace.baseline)));
+        const currentArtifact = this.artifacts.prepare(child, JSON.stringify(tree)), baseArtifact = this.artifacts.prepare(child, JSON.stringify(base));
+        currentArtifact.commit();
+        baseArtifact.commit();
+        return {
+            artifact_id: currentArtifact.id,
+            base_artifact: baseArtifact.id,
+            digest: digest(tree),
+        };
+    }
+    tree(binding) {
+        if (!binding.repository)
+            throw new ServiceError('authority_denied', 'No repository snapshot grant');
+        const tree = JSON.parse(this.artifacts.read(binding.repository.artifact_id));
+        if (digest(tree) !== binding.repository.digest)
+            throw new ServiceError('artifact_corrupt', 'Repository snapshot changed');
+        return tree;
+    }
+    read(binding, args) {
+        const tree = this.tree(binding), action = string(args.action, 'action', 32), offset = integer(args.offset ?? 0, 'offset');
+        const identity = {
+            workspace_id: binding.workspace?.id,
+            revision: binding.workspace?.revision,
+            digest: binding.repository.digest,
+            artifact_id: binding.repository.artifact_id,
+        };
+        if (action === 'inspect')
+            return { ...identity, authority: 'snapshot-read-only' };
+        if (action === 'list') {
+            const paths = Object.keys(tree).sort();
+            return {
+                ...identity,
+                files: paths.slice(offset, offset + 20).map((path) => ({
+                    path,
+                    hash: digest(tree[path]),
+                    bytes: Buffer.from(tree[path].content, 'base64').length,
+                })),
+                next_offset: offset + 20 < paths.length ? offset + 20 : null,
+            };
+        }
+        if (action === 'read') {
+            const path = repositoryPath(args.path), file = tree[path];
+            if (!file)
+                throw new ServiceError('not_found', 'Snapshot file not found', 404);
+            const bytes = Buffer.from(file.content, 'base64'), text = bytes.toString('utf8');
+            if (text.includes('\0') || !Buffer.from(text).equals(bytes))
+                throw new ServiceError('binary_file', 'File is not UTF-8 text');
+            const lines = text.split('\n'), page = [];
+            let used = 0, next = offset;
+            while (next < lines.length && page.length < 100) {
+                const line = lines[next];
+                if (Buffer.byteLength(line) > 4096)
+                    throw new ServiceError('line_limit', 'Line exceeds text limit');
+                if ((used += Buffer.byteLength(line)) > 8192)
+                    break;
+                page.push({ line: next + 1, text: line });
+                next++;
+            }
+            return {
+                ...identity,
+                path,
+                hash: digest(file),
+                lines: page,
+                next_offset: next < lines.length ? next : null,
+            };
+        }
+        if (action === 'search') {
+            const query = string(args.query, 'query', 256), matches = [];
+            let index = 0, next = null;
+            outer: for (const path of Object.keys(tree).sort()) {
+                const bytes = Buffer.from(tree[path].content, 'base64'), text = bytes.toString('utf8');
+                if (text.includes('\0') || !Buffer.from(text).equals(bytes))
+                    continue;
+                const lines = text.split('\n');
+                for (let line = 0; line < lines.length; line++)
+                    if (lines[line].includes(query)) {
+                        if (index++ < offset)
+                            continue;
+                        if (matches.length === 10) {
+                            next = index - 1;
+                            break outer;
+                        }
+                        matches.push({
+                            path,
+                            line: line + 1,
+                            text: lines[line].slice(0, 512),
+                            hash: digest(tree[path]),
+                        });
+                    }
+            }
+            return { ...identity, matches, next_offset: next };
+        }
+        if (action === 'diff' && binding.profile.role === 'reviewer') {
+            const base = JSON.parse(this.artifacts.read(binding.repository.base_artifact));
+            const paths = [...new Set([...Object.keys(base), ...Object.keys(tree)])]
+                .sort()
+                .filter((path) => digest(base[path] ?? null) !== digest(tree[path] ?? null));
+            return {
+                ...identity,
+                changes: paths.slice(offset, offset + 5).map((path) => ({
+                    path,
+                    before_hash: base[path] ? digest(base[path]) : null,
+                    after_hash: tree[path] ? digest(tree[path]) : null,
+                    diff: workspaceDiff({
+                        path,
+                        before: base[path] ?? null,
+                        after: tree[path] ?? null,
+                    }).slice(0, 8192),
+                })),
+                next_offset: offset + 5 < paths.length ? offset + 5 : null,
+            };
+        }
+        throw new ServiceError('authority_denied', 'Specialists can only inspect, list, search or read their snapshot; reviewers can inspect its diff');
+    }
+    report(binding, raw) {
+        if (!binding.tools.includes('salaam_findings'))
+            throw new ServiceError('authority_denied', 'No findings grant');
+        if (!Array.isArray(raw) || raw.length > 32)
+            throw new ServiceError('invalid_field', 'At most 32 findings');
+        const tree = this.tree(binding);
+        const findings = raw.map((item) => {
+            if (!item || typeof item !== 'object' || Array.isArray(item))
+                throw new ServiceError('invalid_field', 'Invalid finding');
+            const f = item, path = repositoryPath(f.path), file = tree[path];
+            if (!file)
+                throw new ServiceError('not_found', 'Finding file is absent from the reviewed snapshot', 404);
+            const line = integer(f.line, 'line'), end = integer(f.end_line ?? line, 'end_line'), severity = string(f.severity, 'severity', 16);
+            const source = Buffer.from(file.content, 'base64').toString('utf8').split('\n');
+            if (!['critical', 'high', 'medium', 'low'].includes(severity) ||
+                line < 1 ||
+                end < line ||
+                end >= line + 20 ||
+                end > source.length)
+                throw new ServiceError('invalid_field', 'Invalid finding location or severity');
+            return {
+                path,
+                line,
+                end_line: end,
+                severity,
+                message: string(f.message, 'message', 2048),
+                hash: digest(file),
+                evidence: source
+                    .slice(line - 1, end)
+                    .join('\n')
+                    .slice(0, 8192),
+            };
+        });
+        const input = digest(findings);
+        return this.store.transaction(() => {
+            const prior = this.store.db
+                .prepare('SELECT * FROM specialist_reports WHERE worker_id=?')
+                .get(binding.worker_id);
+            if (prior) {
+                if (prior.input_digest !== input)
+                    throw new ServiceError('request_conflict', 'Final findings already bind different content');
+                return {
+                    artifact_id: String(prior.artifact_id),
+                    kind: 'analysis',
+                    verified_success: false,
+                };
+            }
+            const artifact = this.artifacts.prepare(binding.session_id, JSON.stringify({
+                schema_version: 1,
+                worker_id: binding.worker_id,
+                attempt_id: binding.attempt_id,
+                binding_digest: digest(binding),
+                snapshot_digest: binding.repository.digest,
+                kind: 'analysis',
+                findings,
+            }));
+            artifact.commit();
+            this.store.db
+                .prepare('INSERT INTO specialist_reports VALUES (?,?,?)')
+                .run(binding.worker_id, input, artifact.id);
+            this.store.event(binding.owner_session, 'specialist.findings', {
+                worker_id: binding.worker_id,
+                artifact_id: artifact.id,
+                kind: 'analysis',
+            });
+            return { artifact_id: artifact.id, kind: 'analysis', verified_success: false };
+        });
+    }
+}