@xfey/tenso 0.1.130

package/dist/providers/openai/sdk-procedure-runner.js

@@ -0,0 +1,140 @@
+import OpenAI from "openai";
+import { classifyOpenAiCredentialValidationError, isOpenAiCredentialValidationFailureRetryable, summarizeOpenAiCredentialValidationError, } from "./credential-validation.js";
+import { extractOpenAiResponseTokenUsage } from "./token-usage.js";
+export class OpenAiStructuredOutputError extends Error {
+    reason;
+    retryable;
+    invalidResponseKind;
+    details;
+    constructor(reason, retryable, message, invalidResponseKind, providerDiagnostic) {
+        super(message);
+        this.reason = reason;
+        this.retryable = retryable;
+        this.invalidResponseKind = invalidResponseKind;
+        this.name = "OpenAiStructuredOutputError";
+        this.details = {
+            reason,
+            retryable,
+            ...(invalidResponseKind === undefined ? {} : { invalid_response_kind: invalidResponseKind }),
+            ...(providerDiagnostic === undefined ? {} : { provider_diagnostic: providerDiagnostic }),
+        };
+    }
+}
+const DEFAULT_OUTPUT_TOKENS = 4096;
+const DEFAULT_TIMEOUT_MS = 120_000;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function createOpenAiStructuredOutputClient(input) {
+    if (input.credentialLease !== undefined) {
+        const { credentialLease, ...connection } = input;
+        return {
+            responses: {
+                create: (body, options) => {
+                    const timeout = options?.timeout ?? DEFAULT_TIMEOUT_MS;
+                    if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 1_200_000)
+                        return Promise.reject(new Error("managed_invocation_timeout_invalid"));
+                    return credentialLease(timeout, (apiKey) => createOpenAiStructuredOutputClient({ ...connection, apiKey }).responses.create(body, {
+                        ...options,
+                        timeout,
+                        maxRetries: 0,
+                    }));
+                },
+            },
+        };
+    }
+    const clientOptions = {
+        apiKey: input.apiKey,
+        maxRetries: 0,
+        timeout: DEFAULT_TIMEOUT_MS,
+    };
+    if (input.apiBaseUrl !== undefined) {
+        clientOptions.baseURL = input.apiBaseUrl;
+    }
+    if (input.organizationId !== undefined) {
+        clientOptions.organization = input.organizationId;
+    }
+    if (input.openAiProjectId !== undefined) {
+        clientOptions.project = input.openAiProjectId;
+    }
+    return new OpenAI(clientOptions);
+}
+function extractOutputText(response) {
+    if (!isRecord(response) || typeof response.output_text !== "string") {
+        throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response did not include output_text", "missing_output_text");
+    }
+    const outputText = response.output_text.trim();
+    if (outputText.length === 0) {
+        throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response was empty", "empty_output_text");
+    }
+    return outputText;
+}
+function parseOutputJson(rawText) {
+    try {
+        return JSON.parse(rawText);
+    }
+    catch {
+        throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response was not valid JSON", "malformed_json");
+    }
+}
+function shouldRetryStructuredOutputError(error) {
+    return (error.reason === "provider_invalid_response" &&
+        (error.invalidResponseKind === "missing_output_text" ||
+            error.invalidResponseKind === "empty_output_text"));
+}
+export async function runOpenAiStructuredOutput(options) {
+    const client = options.client;
+    if (client === undefined) {
+        throw new OpenAiStructuredOutputError("provider_invalid_response", false, "OpenAI structured output client was not configured");
+    }
+    const maxAttempts = Math.max(1, Math.floor(options.maxAttempts ?? 2));
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            const response = await client.responses.create({
+                model: options.model,
+                input: options.input,
+                instructions: options.instructions,
+                max_output_tokens: options.maxOutputTokens ?? DEFAULT_OUTPUT_TOKENS,
+                store: false,
+                text: {
+                    format: {
+                        type: "json_schema",
+                        name: options.schemaName,
+                        schema: options.schema,
+                        ...(options.schemaDescription === undefined
+                            ? {}
+                            : { description: options.schemaDescription }),
+                        strict: true,
+                    },
+                },
+            }, {
+                timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+                maxRetries: 0,
+            });
+            const rawText = extractOutputText(response);
+            const parsed = parseOutputJson(rawText);
+            if (options.validate !== undefined && !options.validate(parsed)) {
+                throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response failed local schema validation", "schema_invalid");
+            }
+            const usage = extractOpenAiResponseTokenUsage(response);
+            return {
+                output: parsed,
+                raw_text: rawText,
+                ...(usage === undefined ? {} : { usage }),
+            };
+        }
+        catch (error) {
+            if (error instanceof OpenAiStructuredOutputError) {
+                if (attempt < maxAttempts && shouldRetryStructuredOutputError(error)) {
+                    continue;
+                }
+                throw error;
+            }
+            const reason = classifyOpenAiCredentialValidationError(error);
+            const retryable = isOpenAiCredentialValidationFailureRetryable(reason);
+            throw new OpenAiStructuredOutputError(reason, retryable, "OpenAI structured output request failed", undefined, summarizeOpenAiCredentialValidationError(error, reason));
+        }
+    }
+    throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response was empty", "empty_output_text");
+}
+//# sourceMappingURL=sdk-procedure-runner.js.map

package/dist/providers/openai/token-usage.d.ts

@@ -0,0 +1,11 @@
+import type { CodexAppServerJsonRpcNotification } from "./app-server/json-rpc.js";
+export type OpenAiTokenUsage = {
+    input_tokens: number;
+    cached_input_tokens: number;
+    output_tokens: number;
+    reasoning_output_tokens: number;
+    total_tokens: number;
+};
+export declare function extractOpenAiResponseTokenUsage(response: unknown): OpenAiTokenUsage | undefined;
+export declare function extractCodexAppServerTokenUsage(notifications: readonly CodexAppServerJsonRpcNotification[]): OpenAiTokenUsage | undefined;
+//# sourceMappingURL=token-usage.d.ts.map

package/dist/providers/openai/token-usage.js

@@ -0,0 +1,90 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readInteger(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readNestedInteger(record, parentKey, ...keys) {
+    const nested = record[parentKey];
+    return isRecord(nested) ? readInteger(nested, ...keys) : undefined;
+}
+function fromPartialUsage(input) {
+    const inputTokens = input.inputTokens ?? 0;
+    const cachedInputTokens = input.cachedInputTokens ?? 0;
+    const outputTokens = input.outputTokens ?? 0;
+    const reasoningOutputTokens = input.reasoningOutputTokens ?? 0;
+    const totalTokens = input.totalTokens ?? inputTokens + outputTokens;
+    if (totalTokens <= 0) {
+        return undefined;
+    }
+    return {
+        input_tokens: inputTokens,
+        cached_input_tokens: cachedInputTokens,
+        output_tokens: outputTokens,
+        reasoning_output_tokens: reasoningOutputTokens,
+        total_tokens: totalTokens,
+    };
+}
+export function extractOpenAiResponseTokenUsage(response) {
+    if (!isRecord(response) || !isRecord(response.usage)) {
+        return undefined;
+    }
+    const inputTokens = readInteger(response.usage, "input_tokens", "inputTokens");
+    const cachedInputTokens = readNestedInteger(response.usage, "input_tokens_details", "cached_tokens", "cachedTokens") ??
+        readNestedInteger(response.usage, "inputTokensDetails", "cached_tokens", "cachedTokens");
+    const outputTokens = readInteger(response.usage, "output_tokens", "outputTokens");
+    const reasoningOutputTokens = readNestedInteger(response.usage, "output_tokens_details", "reasoning_tokens", "reasoningTokens") ??
+        readNestedInteger(response.usage, "outputTokensDetails", "reasoning_tokens", "reasoningTokens");
+    const totalTokens = readInteger(response.usage, "total_tokens", "totalTokens");
+    return fromPartialUsage({
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }),
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        ...(reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens }),
+        ...(totalTokens === undefined ? {} : { totalTokens }),
+    });
+}
+function tokenUsageFromCodexParams(params) {
+    if (!isRecord(params) || !isRecord(params.tokenUsage)) {
+        return undefined;
+    }
+    const total = isRecord(params.tokenUsage.total)
+        ? params.tokenUsage.total
+        : isRecord(params.tokenUsage.last)
+            ? params.tokenUsage.last
+            : undefined;
+    if (total === undefined) {
+        return undefined;
+    }
+    const inputTokens = readInteger(total, "inputTokens", "input_tokens");
+    const cachedInputTokens = readInteger(total, "cachedInputTokens", "cached_input_tokens");
+    const outputTokens = readInteger(total, "outputTokens", "output_tokens");
+    const reasoningOutputTokens = readInteger(total, "reasoningOutputTokens", "reasoning_output_tokens");
+    const totalTokens = readInteger(total, "totalTokens", "total_tokens");
+    return fromPartialUsage({
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }),
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        ...(reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens }),
+        ...(totalTokens === undefined ? {} : { totalTokens }),
+    });
+}
+export function extractCodexAppServerTokenUsage(notifications) {
+    for (const notification of notifications.toReversed()) {
+        if (notification.method !== "thread/tokenUsage/updated") {
+            continue;
+        }
+        const usage = tokenUsageFromCodexParams(notification.params);
+        if (usage !== undefined) {
+            return usage;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=token-usage.js.map

package/dist/reference-access/cache.d.ts

@@ -0,0 +1,50 @@
+export declare class ReferenceCacheError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export type ReferenceCopy = {
+    source_ref: string;
+    revision: string;
+    sha256: string;
+    path: string;
+    size_bytes: number;
+    media_type: string;
+    checked_at: string;
+};
+export type ReferenceFetchResult = {
+    revision: string;
+    media_type: string;
+    content: Uint8Array;
+};
+export declare class ExternalReferenceCache {
+    private readonly options;
+    private readonly workspace;
+    private readonly ledgerFile;
+    private readonly ledger;
+    private tail;
+    constructor(options: {
+        workspaceRoot: string;
+        ledgerRoot: string;
+        now?: () => number;
+        maxTotalBytes?: number;
+        retentionMs?: number;
+    });
+    private now;
+    private validateLedger;
+    private save;
+    private bytes;
+    /** A pin belongs to a server-issued invocation, never to model-supplied identity. */
+    acquire(input: {
+        sourceRef: string;
+        invocationRef: string;
+        expiresAt: number;
+        fetch: () => Promise<ReferenceFetchResult>;
+    }): Promise<{
+        copy: ReferenceCopy;
+        cache_hit: boolean;
+        content: Buffer;
+    }>;
+    private projection;
+    private prune;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/reference-access/cache.js

@@ -0,0 +1,268 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { assertReferenceCacheIsolation, initializeReferenceCacheDirectory, REFERENCE_CACHE_PATH, } from "../workspace-ops/reference-cache-policy.js";
+const MAX_BYTES = 10 * 1024 * 1024;
+const SAFE_REF = /^[A-Za-z0-9_-]{1,128}$/u;
+const DIGEST = /^[a-f0-9]{64}$/u;
+const MAX_PIN_MS = 24 * 60 * 60 * 1000;
+export class ReferenceCacheError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ReferenceCacheError";
+    }
+}
+function fail() {
+    throw new ReferenceCacheError("reference_cache_invalid");
+}
+function hash(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function regular(path) {
+    const stat = lstatSync(path, { throwIfNoEntry: false });
+    if (stat === undefined)
+        return false;
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1)
+        fail();
+    return true;
+}
+function ensureDirectories(path) {
+    const absolute = resolve(path);
+    const parent = dirname(absolute);
+    if (parent !== absolute)
+        ensureDirectories(parent);
+    const stat = lstatSync(absolute, { throwIfNoEntry: false });
+    if (stat !== undefined) {
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            fail();
+    }
+    else
+        mkdirSync(absolute, { mode: 0o700 });
+}
+function relativeCopyPath(source, digest) {
+    return `${REFERENCE_CACHE_PATH}/${source}/${digest}.bin`;
+}
+export class ExternalReferenceCache {
+    options;
+    workspace;
+    ledgerFile;
+    ledger;
+    tail = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+        this.workspace = realpathSync(options.workspaceRoot);
+        if ((options.maxTotalBytes !== undefined &&
+            (!Number.isSafeInteger(options.maxTotalBytes) || options.maxTotalBytes < 1)) ||
+            (options.retentionMs !== undefined &&
+                (!Number.isSafeInteger(options.retentionMs) || options.retentionMs < 0)))
+            fail();
+        const ledgerRoot = resolve(options.ledgerRoot);
+        if (ledgerRoot === this.workspace || ledgerRoot.startsWith(`${this.workspace}/`))
+            fail();
+        ensureDirectories(ledgerRoot);
+        this.ledgerFile = join(ledgerRoot, "cache.json");
+        if (regular(this.ledgerFile)) {
+            try {
+                const parsed = JSON.parse(readFileSync(this.ledgerFile, "utf8"));
+                this.ledger = this.validateLedger(parsed);
+            }
+            catch {
+                fail();
+            }
+        }
+        else {
+            this.ledger = { version: 1, workspace: this.workspace, entries: {}, pins: {} };
+        }
+        initializeReferenceCacheDirectory(this.workspace);
+        this.save();
+    }
+    now() {
+        return (this.options.now ?? Date.now)();
+    }
+    validateLedger(value) {
+        if (value === null || typeof value !== "object")
+            fail();
+        const candidate = value;
+        if (candidate.version !== 1 ||
+            candidate.workspace !== this.workspace ||
+            !candidate.entries ||
+            !candidate.pins ||
+            typeof candidate.entries !== "object" ||
+            typeof candidate.pins !== "object" ||
+            Array.isArray(candidate.entries) ||
+            Array.isArray(candidate.pins))
+            fail();
+        for (const [key, entry] of Object.entries(candidate.entries)) {
+            if (!entry ||
+                !SAFE_REF.test(entry.source_ref) ||
+                !DIGEST.test(entry.sha256) ||
+                key !== `${entry.source_ref}:${entry.sha256}` ||
+                entry.path !== relativeCopyPath(entry.source_ref, entry.sha256) ||
+                typeof entry.revision !== "string" ||
+                entry.revision.length > 256 ||
+                typeof entry.media_type !== "string" ||
+                entry.media_type.length > 128 ||
+                !Number.isSafeInteger(entry.size_bytes) ||
+                entry.size_bytes < 0 ||
+                entry.size_bytes > MAX_BYTES ||
+                !Number.isFinite(entry.last_used_at) ||
+                !Number.isFinite(Date.parse(entry.checked_at)))
+                fail();
+        }
+        for (const [key, pin] of Object.entries(candidate.pins)) {
+            if (!/^[a-f0-9]{64}$/u.test(key) ||
+                !pin ||
+                !Number.isFinite(pin.expires_at) ||
+                !Object.hasOwn(candidate.entries, pin.key) ||
+                !pin.copy ||
+                pin.copy.path !== candidate.entries[pin.key]?.path ||
+                pin.copy.sha256 !== candidate.entries[pin.key]?.sha256 ||
+                pin.copy.source_ref !== candidate.entries[pin.key]?.source_ref ||
+                pin.copy.size_bytes !== candidate.entries[pin.key]?.size_bytes ||
+                typeof pin.copy.media_type !== "string" ||
+                pin.copy.media_type.length > 128 ||
+                typeof pin.copy.revision !== "string" ||
+                !pin.copy.revision ||
+                pin.copy.revision.length > 256 ||
+                !Number.isFinite(Date.parse(pin.copy.checked_at)))
+                fail();
+        }
+        return candidate;
+    }
+    save() {
+        regular(this.ledgerFile);
+        const temporary = `${this.ledgerFile}.${randomUUID()}.tmp`;
+        writeFileSync(temporary, JSON.stringify(this.ledger), { flag: "wx", mode: 0o600 });
+        renameSync(temporary, this.ledgerFile);
+    }
+    bytes(entry) {
+        assertReferenceCacheIsolation(this.workspace, true);
+        const directory = join(this.workspace, REFERENCE_CACHE_PATH, entry.source_ref);
+        const stat = lstatSync(directory, { throwIfNoEntry: false });
+        if (!stat?.isDirectory() || stat.isSymbolicLink())
+            fail();
+        const path = join(this.workspace, entry.path);
+        if (!regular(path))
+            throw new ReferenceCacheError("reference_cache_missing");
+        if (lstatSync(path).size !== entry.size_bytes)
+            fail();
+        const content = readFileSync(path);
+        if (hash(content) !== entry.sha256)
+            fail();
+        return content;
+    }
+    /** A pin belongs to a server-issued invocation, never to model-supplied identity. */
+    async acquire(input) {
+        if (!SAFE_REF.test(input.sourceRef) ||
+            !SAFE_REF.test(input.invocationRef) ||
+            !Number.isFinite(input.expiresAt) ||
+            input.expiresAt <= this.now() ||
+            input.expiresAt > this.now() + MAX_PIN_MS)
+            fail();
+        const operation = this.tail.then(async () => {
+            if (input.expiresAt <= this.now())
+                throw new ReferenceCacheError("reference_invocation_expired");
+            assertReferenceCacheIsolation(this.workspace, true);
+            const pinKey = hash(Buffer.from(`${input.invocationRef}\0${input.sourceRef}`));
+            const pin = this.ledger.pins[pinKey];
+            if (pin !== undefined && pin.expires_at > this.now()) {
+                const entry = this.ledger.entries[pin.key];
+                if (entry === undefined)
+                    fail();
+                const content = this.bytes(entry);
+                entry.last_used_at = this.now();
+                this.save();
+                return { copy: pin.copy, cache_hit: true, content };
+            }
+            // A new invocation checks access and content. Failures never silently use stale bytes.
+            const fetched = await input.fetch();
+            assertReferenceCacheIsolation(this.workspace, true);
+            if (input.expiresAt <= this.now())
+                throw new ReferenceCacheError("reference_invocation_expired");
+            if (fetched.content.byteLength > MAX_BYTES ||
+                !fetched.revision ||
+                fetched.revision.length > 256 ||
+                !fetched.media_type ||
+                fetched.media_type.length > 128)
+                fail();
+            const content = Buffer.from(fetched.content);
+            const digest = hash(content);
+            const key = `${input.sourceRef}:${digest}`;
+            const existing = this.ledger.entries[key];
+            this.prune(content.byteLength, key);
+            const entry = {
+                source_ref: input.sourceRef,
+                revision: fetched.revision,
+                sha256: digest,
+                path: relativeCopyPath(input.sourceRef, digest),
+                size_bytes: content.byteLength,
+                media_type: fetched.media_type,
+                checked_at: new Date(this.now()).toISOString(),
+                last_used_at: this.now(),
+            };
+            ensureDirectories(join(this.workspace, REFERENCE_CACHE_PATH, input.sourceRef));
+            const path = join(this.workspace, entry.path);
+            if (existing !== undefined && regular(path))
+                this.bytes(existing);
+            else if (regular(path)) {
+                // Response-loss/crash orphan: adopt only an exact content-addressed regular file.
+                if (!readFileSync(path).equals(content))
+                    fail();
+            }
+            else {
+                const temporary = `${path}.${randomUUID()}.tmp`;
+                writeFileSync(temporary, content, { flag: "wx", mode: 0o600 });
+                renameSync(temporary, path);
+            }
+            // Each version records its own observation. Pins capture revision independently below.
+            this.ledger.entries[key] = entry;
+            this.ledger.pins[pinKey] = { key, expires_at: input.expiresAt, copy: this.projection(entry) };
+            this.save();
+            return { copy: this.projection(entry), cache_hit: existing !== undefined, content };
+        });
+        this.tail = operation.catch(() => undefined);
+        return operation;
+    }
+    projection(entry) {
+        return {
+            source_ref: entry.source_ref,
+            revision: entry.revision,
+            sha256: entry.sha256,
+            path: entry.path,
+            size_bytes: entry.size_bytes,
+            media_type: entry.media_type,
+            checked_at: entry.checked_at,
+        };
+    }
+    prune(incomingBytes, incomingKey) {
+        const now = this.now();
+        for (const [key, pin] of Object.entries(this.ledger.pins)) {
+            if (pin.expires_at <= now)
+                delete this.ledger.pins[key];
+        }
+        const protectedKeys = new Set(Object.values(this.ledger.pins).map((pin) => pin.key));
+        const entries = Object.entries(this.ledger.entries).sort((a, b) => a[1].last_used_at - b[1].last_used_at);
+        let total = entries.reduce((sum, [, entry]) => sum + entry.size_bytes, 0);
+        const additional = Object.hasOwn(this.ledger.entries, incomingKey) ? 0 : incomingBytes;
+        const maximum = this.options.maxTotalBytes ?? 100 * 1024 * 1024;
+        const retention = this.options.retentionMs ?? 7 * 24 * 60 * 60 * 1000;
+        for (const [key, entry] of entries) {
+            if (key === incomingKey || protectedKeys.has(key))
+                continue;
+            if (total + additional <= maximum && entry.last_used_at + retention > now)
+                continue;
+            if (regular(join(this.workspace, entry.path))) {
+                this.bytes(entry); // Reject replacement/symlink/tampering before removal.
+                unlinkSync(join(this.workspace, entry.path));
+            }
+            delete this.ledger.entries[key];
+            total -= entry.size_bytes;
+        }
+        this.save();
+        if (total + additional > maximum)
+            throw new ReferenceCacheError("reference_cache_capacity");
+    }
+}
+//# sourceMappingURL=cache.js.map

package/dist/reference-access/message-context.d.ts

@@ -0,0 +1,6 @@
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+/** Location hints, not access grants or current-read evidence. Never copy private locators. */
+export declare function externalReferenceMessageContext(refs: MessageProjection["refs"]): {
+    external_reference_sources?: string[];
+};
+//# sourceMappingURL=message-context.d.ts.map

package/dist/reference-access/message-context.js

@@ -0,0 +1,14 @@
+/** Location hints, not access grants or current-read evidence. Never copy private locators. */
+export function externalReferenceMessageContext(refs) {
+    const sources = [
+        ...(refs?.external_references?.map((source) => source.source_ref) ?? []),
+        ...(refs?.external_reference_reads ?? []),
+        ...(refs?.reply_context?.status === "resolved"
+            ? refs.reply_context.external_reference_sources
+            : []),
+    ];
+    return sources.length === 0
+        ? {}
+        : { external_reference_sources: [...new Set(sources)].slice(0, 16) };
+}
+//# sourceMappingURL=message-context.js.map

package/dist/reference-access/message-links.d.ts

@@ -0,0 +1,4 @@
+import { type MessageProjection } from "@tutti/shared/schemas/api";
+/** Only authored chat links. File/document contents cannot silently grant another locator. */
+export declare function referenceMessageLinks(message: MessageProjection): string[];
+//# sourceMappingURL=message-links.d.ts.map

package/dist/reference-access/message-links.js

@@ -0,0 +1,13 @@
+import { parseFeishuExternalReferenceInput, } from "@tutti/shared/schemas/api";
+/** Only authored chat links. File/document contents cannot silently grant another locator. */
+export function referenceMessageLinks(message) {
+    if (message.author.kind !== "human" && message.refs?.development_operator !== true)
+        return [];
+    const links = message.body.match(/https:\/\/[^\s<>"'\u3000]+/giu) ?? [];
+    return [
+        ...new Set(links
+            .map((link) => link.replace(/[),.;!?\]}>，。；！？）]+$/u, ""))
+            .filter((link) => parseFeishuExternalReferenceInput(link) !== null)),
+    ].slice(0, 16);
+}
+//# sourceMappingURL=message-links.js.map

package/dist/reference-access/read-evidence.d.ts

@@ -0,0 +1,10 @@
+import type { SqliteDatabase } from "../store/index.js";
+import type { ReferenceCopy } from "./cache.js";
+import type { ReferenceInvocation } from "./service.js";
+import type { ReferenceAuthorization } from "@tutti/shared/schemas/api";
+export declare function recordExternalReferenceAccessRequirement(db: SqliteDatabase, invocation: ReferenceInvocation, requestRef: string, authorization: ReferenceAuthorization, now?: () => Date): void;
+/** Prior answer context only: a source reference is not proof of freshness in a later turn. */
+export declare function readExternalReferenceReadSources(db: SqliteDatabase, invocationRef: string): string[];
+/** Durable observation, separate from evictable cache metadata; no content or locator. */
+export declare function recordExternalReferenceRead(db: SqliteDatabase, invocation: ReferenceInvocation, copy: ReferenceCopy): void;
+//# sourceMappingURL=read-evidence.d.ts.map

package/dist/reference-access/read-evidence.js

@@ -0,0 +1,28 @@
+export function recordExternalReferenceAccessRequirement(db, invocation, requestRef, authorization, now = () => new Date()) {
+    db.prepare(`INSERT OR IGNORE INTO external_reference_access_requirements
+    (invocation_ref, request_ref, activity_ref, authorization_ref, profile, observed_at)
+    VALUES (?, ?, ?, ?, ?, ?)`).run(invocation.reference_invocation_ref, requestRef, invocation.activity_ref ?? null, authorization.authorization_ref, authorization.profile, now().toISOString());
+}
+/** Prior answer context only: a source reference is not proof of freshness in a later turn. */
+export function readExternalReferenceReadSources(db, invocationRef) {
+    return db
+        .prepare(`SELECT source_ref FROM external_reference_reads
+       WHERE invocation_ref = ? ORDER BY checked_at, source_ref LIMIT 16`)
+        .all(invocationRef)
+        .map((row) => row.source_ref);
+}
+/** Durable observation, separate from evictable cache metadata; no content or locator. */
+export function recordExternalReferenceRead(db, invocation, copy) {
+    const invocationRef = invocation.reference_invocation_ref;
+    const existing = db
+        .prepare(`
+    SELECT revision, content_sha256 FROM external_reference_reads WHERE invocation_ref = ? AND source_ref = ?`)
+        .get(invocationRef, copy.source_ref);
+    if (existing &&
+        (existing.revision !== copy.revision || existing.content_sha256 !== copy.sha256)) {
+        throw new Error("reference_read_evidence_conflict");
+    }
+    db.prepare(`INSERT OR IGNORE INTO external_reference_reads
+    (invocation_ref, activity_ref, source_ref, revision, content_sha256, size_bytes, checked_at) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(invocationRef, invocation.activity_ref ?? null, copy.source_ref, copy.revision, copy.sha256, copy.size_bytes, copy.checked_at);
+}
+//# sourceMappingURL=read-evidence.js.map