@xfey/tenso 0.1.130

package/dist/server-shell/http/routes/agent-context-external-reference-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import type { AgentContextRouteOptions } from "./agent-context-shared.js";
+export declare function registerAgentContextExternalReferenceRoutes(app: FastifyInstance, options: AgentContextRouteOptions): void;
+//# sourceMappingURL=agent-context-external-reference-routes.d.ts.map

package/dist/server-shell/http/routes/agent-context-external-reference-routes.js

@@ -0,0 +1,185 @@
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { redactText } from "@tutti/shared/utils";
+import { ExternalReferenceTransportError } from "@tutti/relay-client";
+import { ReferenceCacheError } from "../../../reference-access/cache.js";
+import { ReferenceAuthorizationRequiredError } from "../../../reference-access/service.js";
+import { referenceMessageLinks } from "../../../reference-access/message-links.js";
+import { readMessageProjectionById } from "../../../collaboration-state/index.js";
+import { MessageIdSchema } from "@tutti/shared/schemas/domain";
+import { requireProjectStore } from "./agent-context-shared.js";
+import { randomUUID } from "node:crypto";
+import { WorkspaceOpsError } from "../../../workspace-ops/errors.js";
+import { authorizeAgentContextRequest } from "./agent-context-auth.js";
+import { AGENT_CONTEXT_BASE_PATH } from "./agent-context-shared.js";
+const ResolveMessageLinkBody = Type.Object({ message_id: MessageIdSchema, link_index: Type.Integer({ minimum: 0, maximum: 15 }) }, { additionalProperties: false });
+export function registerAgentContextExternalReferenceRoutes(app, options) {
+    app.post(`${AGENT_CONTEXT_BASE_PATH}/references/external/resolve`, {
+        bodyLimit: 4096,
+        schema: { body: ResolveMessageLinkBody },
+        preValidation: async (request, reply) => {
+            reply.header("cache-control", "no-store");
+            if (!Value.Check(ResolveMessageLinkBody, request.body))
+                return reply
+                    .code(400)
+                    .send({ kind: "unavailable", reason: "reference_message_link_invalid" });
+        },
+    }, async (request, reply) => {
+        reply.header("cache-control", "no-store");
+        const invocation = authorizeAgentContextRequest(request, options, "references:external");
+        const requestRef = `eref_${randomUUID().replaceAll("-", "")}`;
+        const fields = {
+            request_ref: requestRef,
+            invocation_ref: invocation.reference_invocation_ref,
+            activity_ref: invocation.activity_ref,
+            message_ref: request.body.message_id,
+            link_index: request.body.link_index,
+            stage: "external_reference_resolve",
+        };
+        const started = performance.now();
+        try {
+            if (!options.externalReferences)
+                throw new ReferenceCacheError("external_references_not_enabled");
+            const message = readMessageProjectionById(requireProjectStore(options).db, request.body.message_id);
+            const url = message ? referenceMessageLinks(message)[request.body.link_index] : undefined;
+            if (!url)
+                throw new ReferenceCacheError("reference_message_link_not_found");
+            const source = await options.externalReferences.resolve(invocation, url);
+            request.log.info({
+                ...fields,
+                source_ref: source.source_ref,
+                elapsed_ms: Math.round(performance.now() - started),
+                outcome: "resolved",
+            }, "Message material resolved");
+            return { source, request_ref: requestRef };
+        }
+        catch (error) {
+            const reason = error instanceof ReferenceAuthorizationRequiredError
+                ? "reference_authorization_required"
+                : error instanceof ReferenceCacheError
+                    ? error.code
+                    : error instanceof ExternalReferenceTransportError
+                        ? error.reasonCode
+                        : "reference_resolve_unavailable";
+            request.log.warn({
+                ...fields,
+                reason_code: reason,
+                ...(error instanceof ReferenceAuthorizationRequiredError
+                    ? { authorization_ref: error.result.authorization.authorization_ref }
+                    : {}),
+                elapsed_ms: Math.round(performance.now() - started),
+            }, "Message material unavailable");
+            return error instanceof ReferenceAuthorizationRequiredError
+                ? { ...error.result, request_ref: requestRef }
+                : { kind: "unavailable", reason, request_ref: requestRef };
+        }
+    });
+    for (const action of ["list", "read"])
+        app.get(`${AGENT_CONTEXT_BASE_PATH}/references/external${action === "read" ? "/file" : ""}`, {
+            schema: {
+                querystring: action === "read"
+                    ? Type.Object({ source_ref: Type.String({ pattern: "^external_ref_[a-f0-9]{32}$" }) }, { additionalProperties: false })
+                    : Type.Object({}, { additionalProperties: false }),
+            },
+        }, async (request, reply) => {
+            reply.header("cache-control", "no-store");
+            const invocation = authorizeAgentContextRequest(request, options, "references:external");
+            const started = performance.now();
+            const diagnosticFields = {
+                action,
+                invocation_ref: invocation.reference_invocation_ref,
+                activity_ref: invocation.activity_ref,
+            };
+            request.log.info({ ...diagnosticFields, stage: "external_reference_request" }, "External Reference request started");
+            const service = options.externalReferences;
+            if (!service) {
+                request.log.info({
+                    ...diagnosticFields,
+                    stage: "external_reference_unavailable",
+                    reason_code: "external_references_not_enabled",
+                }, "External Reference service unavailable");
+                return { kind: "unavailable", reason: "external_references_not_enabled" };
+            }
+            const sourceRef = request.query.source_ref;
+            if (action === "read" &&
+                (sourceRef === undefined || !/^external_ref_[a-f0-9]{32}$/u.test(sourceRef)))
+                return { kind: "unavailable", reason: "reference_source_invalid" };
+            try {
+                if (action === "list") {
+                    const items = await service.list(invocation);
+                    request.log.info({
+                        ...diagnosticFields,
+                        stage: "external_reference_list",
+                        source_count: items.length,
+                        elapsed_ms: Math.round(performance.now() - started),
+                    }, "External Reference sources listed");
+                    return { items };
+                }
+                const result = await service.read(invocation, sourceRef);
+                const { copy } = result;
+                request.log.info({
+                    stage: "external_reference_read",
+                    action,
+                    elapsed_ms: Math.round(performance.now() - started),
+                    invocation_ref: invocation.reference_invocation_ref,
+                    activity_ref: invocation.activity_ref,
+                    source_ref: copy.source_ref,
+                    revision: copy.revision,
+                    sha256: copy.sha256,
+                    cache_hit: result.cache_hit,
+                    size_bytes: copy.size_bytes,
+                }, "External Reference working copy ready");
+                let text;
+                if (!result.content.includes(0)) {
+                    try {
+                        text = new TextDecoder("utf-8", { fatal: true }).decode(result.content);
+                    }
+                    catch {
+                        /* Binary resources are available as a controlled local working copy. */
+                    }
+                }
+                const limit = 128 * 1024;
+                const safeText = text === undefined ? undefined : Buffer.from(redactText(text), "utf8");
+                return {
+                    kind: text === undefined ? "local_file" : "text",
+                    ...copy,
+                    cache_hit: result.cache_hit,
+                    provenance: { origin: "external_reference", verification: "this_invocation" },
+                    ...(safeText === undefined
+                        ? {}
+                        : {
+                            text: safeText.subarray(0, limit).toString("utf8"),
+                            truncated: safeText.byteLength > limit,
+                        }),
+                };
+            }
+            catch (error) {
+                if (error instanceof ReferenceAuthorizationRequiredError) {
+                    request.log.info({
+                        ...diagnosticFields,
+                        stage: "external_reference_authorization_required",
+                        authorization_ref: error.result.authorization.authorization_ref,
+                    }, "Document access card requested");
+                    return error.result;
+                }
+                const reason = error instanceof ReferenceCacheError
+                    ? error.code
+                    : error instanceof ExternalReferenceTransportError
+                        ? error.reasonCode
+                        : error instanceof WorkspaceOpsError
+                            ? "reference_cache_unsafe"
+                            : "reference_read_unavailable";
+                request.log.warn({
+                    stage: "external_reference_unavailable",
+                    action,
+                    elapsed_ms: Math.round(performance.now() - started),
+                    invocation_ref: invocation.reference_invocation_ref,
+                    activity_ref: invocation.activity_ref,
+                    ...(sourceRef === undefined ? {} : { source_ref: sourceRef }),
+                    reason_code: reason,
+                }, "External Reference read unavailable");
+                return { kind: "unavailable", reason };
+            }
+        });
+}
+//# sourceMappingURL=agent-context-external-reference-routes.js.map

package/dist/server-shell/http/routes/agent-context-messages-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import { type AgentContextRouteOptions } from "./agent-context-shared.js";
+export declare function registerAgentContextMessageRoutes(app: FastifyInstance, options: AgentContextRouteOptions): void;
+//# sourceMappingURL=agent-context-messages-routes.d.ts.map

package/dist/server-shell/http/routes/agent-context-messages-routes.js

@@ -0,0 +1,77 @@
+import { readMainChatMessageWindow } from "../../../collaboration-state/index.js";
+import { messageTextForModel } from "../../../collaboration-state/message-context.js";
+import { externalReferenceMessageContext } from "../../../reference-access/message-context.js";
+import { authorizeAgentContextRequest } from "./agent-context-auth.js";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+import { boundedLimit, queryString, truncateText } from "./agent-context-query.js";
+import { AGENT_CONTEXT_BASE_PATH, MESSAGE_BODY_MAX_CHARS, MESSAGE_LIMIT_DEFAULT, MESSAGE_LIMIT_MAX, requireProjectStore, } from "./agent-context-shared.js";
+export function registerAgentContextMessageRoutes(app, options) {
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/messages`, (request) => {
+        authorizeAgentContextRequest(request, options, "messages:read");
+        const query = request.query;
+        const scope = queryString(query.scope) ?? "main_chat";
+        if (scope !== "main_chat") {
+            throw new AgentContextBadRequestError("Message scope is invalid");
+        }
+        const anchorParam = queryString(query.anchor);
+        if (anchorParam !== undefined && anchorParam !== "latest" && anchorParam !== "start") {
+            throw new AgentContextBadRequestError("Message anchor is invalid");
+        }
+        const anchor = anchorParam === "latest" || anchorParam === "start" ? anchorParam : undefined;
+        const cursor = queryString(query.cursor);
+        const limit = boundedLimit(query.limit, {
+            default: MESSAGE_LIMIT_DEFAULT,
+            max: MESSAGE_LIMIT_MAX,
+        });
+        const windowOptions = cursor === undefined
+            ? {
+                limit,
+                ...(anchor === undefined ? {} : { anchor }),
+            }
+            : {
+                limit,
+                before: cursor,
+            };
+        const window = readMainChatMessageWindow(requireProjectStore(options).db, windowOptions);
+        return {
+            scope: "main_chat",
+            items: window.items.map((message) => {
+                const body = truncateText(messageTextForModel(message), MESSAGE_BODY_MAX_CHARS);
+                return {
+                    message_id: message.id,
+                    created_at: message.created_at,
+                    author: {
+                        kind: message.author.kind,
+                        display_name: message.author.display_name ?? message.author.kind,
+                    },
+                    body: body.text,
+                    body_truncated: body.truncated,
+                    ...externalReferenceMessageContext(message.refs),
+                    ...(message.refs?.reference_file === undefined
+                        ? {}
+                        : {
+                            refs: {
+                                reference_file: {
+                                    path: message.refs.reference_file.path,
+                                    name: message.refs.reference_file.name,
+                                    category: message.refs.reference_file.category,
+                                },
+                            },
+                        }),
+                };
+            }),
+            page: {
+                ...(window.window.older_cursor === undefined
+                    ? {}
+                    : { next_cursor: window.window.older_cursor }),
+                ...(window.window.newer_cursor === undefined
+                    ? {}
+                    : { previous_cursor: window.window.newer_cursor }),
+                has_older: window.window.has_older,
+                has_newer: window.window.has_newer,
+                limit: window.window.limit,
+            },
+        };
+    });
+}
+//# sourceMappingURL=agent-context-messages-routes.js.map

package/dist/server-shell/http/routes/agent-context-project-doc-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import { type AgentContextRouteOptions } from "./agent-context-shared.js";
+export declare function registerAgentContextProjectDocRoutes(app: FastifyInstance, options: AgentContextRouteOptions): void;
+//# sourceMappingURL=agent-context-project-doc-routes.d.ts.map

package/dist/server-shell/http/routes/agent-context-project-doc-routes.js

@@ -0,0 +1,86 @@
+import { redactText } from "@tutti/shared/utils";
+import { VIEWER_HARD_READ_LIMIT_BYTES, WorkspaceOpsError, readViewerFile, } from "../../../workspace-ops/index.js";
+import { authorizeAgentContextRequest } from "./agent-context-auth.js";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+import { boundedLimit, queryString } from "./agent-context-query.js";
+import { containsUnconfirmedPlaceholders, isProjectDocKey, projectDocListItems, projectDocPathForKey, projectDocPurpose, projectDocUnavailableReason, } from "./agent-context-project-docs.js";
+import { AGENT_CONTEXT_BASE_PATH, PROJECT_DOC_FILE_DEFAULT_MAX_BYTES, PROJECT_DOC_FILE_MAX_BYTES, requireWorkspaceRoot, } from "./agent-context-shared.js";
+export function registerAgentContextProjectDocRoutes(app, options) {
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/project-docs`, (request) => {
+        authorizeAgentContextRequest(request, options, "project-docs:list");
+        return {
+            docs: projectDocListItems(options),
+            note: [
+                "Missing or unavailable docs are not runtime failures.",
+                "Use repository inspection and explicit human context when the current turn needs",
+                "to create or reason about missing project docs.",
+            ].join(" "),
+        };
+    });
+    app.get(`${AGENT_CONTEXT_BASE_PATH}/project-docs/file`, (request) => {
+        authorizeAgentContextRequest(request, options, "project-docs:read");
+        const docKey = queryString(request.query.doc_key);
+        if (docKey === undefined || !isProjectDocKey(docKey)) {
+            throw new AgentContextBadRequestError("Project doc key is invalid");
+        }
+        const path = projectDocPathForKey(docKey);
+        const maxBytes = Math.min(boundedLimit(request.query.max_bytes, {
+            default: PROJECT_DOC_FILE_DEFAULT_MAX_BYTES,
+            max: PROJECT_DOC_FILE_MAX_BYTES,
+        }), VIEWER_HARD_READ_LIMIT_BYTES);
+        try {
+            const file = readViewerFile({
+                workspaceRoot: requireWorkspaceRoot(options),
+                path,
+                maxBytes,
+                ...(options.now === undefined ? {} : { now: options.now }),
+            });
+            if (file.content.kind !== "text") {
+                return {
+                    kind: "unavailable",
+                    doc_key: docKey,
+                    path,
+                    status: "unreadable",
+                    reason: file.content.reason,
+                    message: "Project doc exists but is not readable as bounded UTF-8 text.",
+                };
+            }
+            const text = redactText(file.content.text);
+            const containsUnconfirmed = containsUnconfirmedPlaceholders(text);
+            return {
+                kind: "text",
+                doc_key: docKey,
+                path: file.file.path,
+                name: file.file.name,
+                purpose: projectDocPurpose(docKey),
+                text,
+                truncated: file.content.truncated,
+                bytes_read: file.content.bytes_returned,
+                contains_unconfirmed_placeholders: containsUnconfirmed,
+                ...(containsUnconfirmed
+                    ? {
+                        completeness_hint: "This project doc contains unconfirmed placeholders; " +
+                            "treat those sections as unresolved context.",
+                    }
+                    : {}),
+            };
+        }
+        catch (error) {
+            if (error instanceof WorkspaceOpsError) {
+                const reason = projectDocUnavailableReason(error);
+                return {
+                    kind: "unavailable",
+                    doc_key: docKey,
+                    path,
+                    status: reason === "missing" ? "missing" : "unavailable",
+                    reason,
+                    message: reason === "missing"
+                        ? "Project doc has not been created yet."
+                        : "Project doc is not currently readable through the context API.",
+                };
+            }
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=agent-context-project-doc-routes.js.map

package/dist/server-shell/http/routes/agent-context-project-docs.d.ts

@@ -0,0 +1,40 @@
+import type { ProjectDocKey } from "@tutti/shared/schemas/api";
+import { WorkspaceOpsError } from "../../../workspace-ops/index.js";
+type AgentContextWorkspaceOptions = {
+    workspaceOps?: {
+        workspaceRoot: string;
+    };
+    now?: () => Date;
+};
+export declare function isProjectDocKey(value: string): value is ProjectDocKey;
+export declare function projectDocPurpose(docKey: ProjectDocKey): string;
+export declare function projectDocUnavailableReason(error: WorkspaceOpsError): string;
+export declare function containsUnconfirmedPlaceholders(text: string): boolean;
+export declare function projectDocPathForKey(docKey: ProjectDocKey): string;
+export declare function projectDocListItems(options: AgentContextWorkspaceOptions): ({
+    doc_key: "product" | "tech" | "structure" | "architecture_principles";
+    path: string;
+    purpose: string;
+    status: "unreadable";
+    reason: string;
+    size_bytes?: never;
+    message?: never;
+} | {
+    doc_key: "product" | "tech" | "structure" | "architecture_principles";
+    path: string;
+    purpose: string;
+    status: "available";
+    size_bytes: number;
+    reason?: never;
+    message?: never;
+} | {
+    doc_key: "product" | "tech" | "structure" | "architecture_principles";
+    path: string;
+    purpose: string;
+    status: "unavailable";
+    reason: string;
+    message: string;
+    size_bytes?: never;
+})[];
+export {};
+//# sourceMappingURL=agent-context-project-docs.d.ts.map

package/dist/server-shell/http/routes/agent-context-project-docs.js

@@ -0,0 +1,98 @@
+import { PROJECT_DOCS } from "../../../project-docs/context.js";
+import { WorkspaceOpsError, readViewerFile, } from "../../../workspace-ops/index.js";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+function requireWorkspaceRoot(options) {
+    if (options.workspaceOps === undefined) {
+        throw new AgentContextBadRequestError("Workspace viewer is unavailable");
+    }
+    return options.workspaceOps.workspaceRoot;
+}
+export function isProjectDocKey(value) {
+    return PROJECT_DOCS.some((doc) => doc.doc_key === value);
+}
+export function projectDocPurpose(docKey) {
+    switch (docKey) {
+        case "product":
+            return "Purpose, target users, key features, and business objectives.";
+        case "tech":
+            return "Frameworks, libraries, development tools, and technical constraints.";
+        case "structure":
+            return "File organization, naming conventions, import patterns, and architectural decisions.";
+        case "architecture_principles":
+            return "Scope, core principles, boundary rules, quality gates, human escalation, and documentation duties.";
+    }
+}
+export function projectDocUnavailableReason(error) {
+    if (error.code === "not_found") {
+        return "missing";
+    }
+    if (error.code === "repo_snapshot_unavailable") {
+        return "repo_snapshot_unavailable";
+    }
+    if (error.code === "forbidden") {
+        return "restricted_path";
+    }
+    if (error.code === "validation_failed") {
+        return "restricted_path";
+    }
+    throw error;
+}
+export function containsUnconfirmedPlaceholders(text) {
+    return /\b(?:to be confirmed|tbd|todo)\b/iu.test(text);
+}
+export function projectDocPathForKey(docKey) {
+    const doc = PROJECT_DOCS.find((candidate) => candidate.doc_key === docKey);
+    if (doc === undefined) {
+        throw new AgentContextBadRequestError("Project doc key is invalid");
+    }
+    return doc.path;
+}
+export function projectDocListItems(options) {
+    return PROJECT_DOCS.map((doc) => projectDocListItem(options, doc));
+}
+function projectDocListItem(options, doc) {
+    try {
+        const file = readViewerFile({
+            workspaceRoot: requireWorkspaceRoot(options),
+            path: doc.path,
+            maxBytes: 1,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        const reason = unavailableReasonForContent(file.content);
+        if (reason !== undefined) {
+            return {
+                doc_key: doc.doc_key,
+                path: doc.path,
+                purpose: projectDocPurpose(doc.doc_key),
+                status: "unreadable",
+                reason,
+            };
+        }
+        return {
+            doc_key: doc.doc_key,
+            path: doc.path,
+            purpose: projectDocPurpose(doc.doc_key),
+            status: "available",
+            size_bytes: file.file.size_bytes,
+        };
+    }
+    catch (error) {
+        if (error instanceof WorkspaceOpsError) {
+            return {
+                doc_key: doc.doc_key,
+                path: doc.path,
+                purpose: projectDocPurpose(doc.doc_key),
+                status: "unavailable",
+                reason: projectDocUnavailableReason(error),
+                message: error.code === "not_found"
+                    ? "Project doc has not been created yet."
+                    : "Project doc is not currently readable through the context API.",
+            };
+        }
+        throw error;
+    }
+}
+function unavailableReasonForContent(content) {
+    return content.kind === "text" ? undefined : content.reason;
+}
+//# sourceMappingURL=agent-context-project-docs.js.map

package/dist/server-shell/http/routes/agent-context-query.d.ts

@@ -0,0 +1,31 @@
+type OffsetCursor = {
+    endpoint: "worklist" | "references" | "skills";
+    offset: number;
+};
+export declare function queryString(value: unknown): string | undefined;
+export declare function boundedLimit(value: unknown, defaults: {
+    default: number;
+    max: number;
+}): number;
+export declare function truncateText(value: string | undefined, maxChars: number): {
+    text: string;
+    truncated: boolean;
+};
+export declare function truncateArray(values: string[], maxItems: number, maxItemChars: number): {
+    items: string[];
+    truncated: boolean;
+};
+export declare function pageByOffset<T>(items: T[], options: {
+    endpoint: OffsetCursor["endpoint"];
+    cursor?: string;
+    limit: number;
+}): {
+    items: T[];
+    page: {
+        limit: number;
+        has_more: boolean;
+        next_cursor?: string;
+    };
+};
+export {};
+//# sourceMappingURL=agent-context-query.d.ts.map

package/dist/server-shell/http/routes/agent-context-query.js

@@ -0,0 +1,72 @@
+import { redactText } from "@tutti/shared/utils";
+import { AgentContextBadRequestError } from "./agent-context-errors.js";
+export function queryString(value) {
+    if (Array.isArray(value)) {
+        return queryString(value[0]);
+    }
+    return typeof value === "string" ? value : undefined;
+}
+export function boundedLimit(value, defaults) {
+    const raw = queryString(value);
+    if (raw === undefined || raw.trim() === "") {
+        return defaults.default;
+    }
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new AgentContextBadRequestError("Limit is invalid");
+    }
+    return Math.min(parsed, defaults.max);
+}
+export function truncateText(value, maxChars) {
+    const redacted = redactText(value ?? "");
+    if (redacted.length <= maxChars) {
+        return { text: redacted, truncated: false };
+    }
+    return { text: redacted.slice(0, maxChars), truncated: true };
+}
+export function truncateArray(values, maxItems, maxItemChars) {
+    const limited = values.slice(0, maxItems);
+    const itemTruncated = limited.map((value) => truncateText(value, maxItemChars));
+    return {
+        items: itemTruncated.map((item) => item.text),
+        truncated: values.length > maxItems || itemTruncated.some((item) => item.truncated),
+    };
+}
+function encodeOffsetCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeOffsetCursor(value, endpoint) {
+    if (value === undefined || value.trim() === "") {
+        return 0;
+    }
+    try {
+        const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed) &&
+            parsed.endpoint === endpoint &&
+            Number.isInteger(parsed.offset) &&
+            parsed.offset >= 0) {
+            return parsed.offset;
+        }
+    }
+    catch {
+        throw new AgentContextBadRequestError("Cursor is invalid");
+    }
+    throw new AgentContextBadRequestError("Cursor is invalid");
+}
+export function pageByOffset(items, options) {
+    const offset = decodeOffsetCursor(options.cursor, options.endpoint);
+    const pageItems = items.slice(offset, offset + options.limit);
+    const nextOffset = offset + pageItems.length;
+    const hasMore = nextOffset < items.length;
+    return {
+        items: pageItems,
+        page: {
+            ...(hasMore ? { next_cursor: encodeOffsetCursor({ endpoint: options.endpoint, offset: nextOffset }) } : {}),
+            limit: options.limit,
+            has_more: hasMore,
+        },
+    };
+}
+//# sourceMappingURL=agent-context-query.js.map

package/dist/server-shell/http/routes/agent-context-reference-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import { type AgentContextRouteOptions } from "./agent-context-shared.js";
+export declare function registerAgentContextReferenceRoutes(app: FastifyInstance, options: AgentContextRouteOptions): void;
+//# sourceMappingURL=agent-context-reference-routes.d.ts.map