@inflexa-ai/harness 0.22.0 → 0.22.1

package/dist/agents/report-session-agent.d.ts

@@ -38,7 +38,7 @@ import type { ThreadStore } from "../memory/thread-store.js";
 import type { ReferenceResolver } from "../report-model/reference-resolver.js";
 import type { ReportVersionStore } from "../state/report-versions.js";
 import type { ReportSessionStateGateway } from "../tools/report-authoring/authoring-tools.js";
-import { type ResolvePageAsset, type ResolvePageUrl, type SessionPagePublisher } from "../tools/report-session/index.js";
+import { type MakeSessionPagePublisher, type ResolvePageAsset, type ResolvePageUrl } from "../tools/report-session/index.js";
 /** Canonical agent id -- distinct from the id of the old templating agent. */
 export declare const REPORT_SESSION_AGENT_ID: "report-session";
 /**
@@ -99,15 +99,18 @@ export interface ReportSessionAgentDeps {
      */
     readonly resolvePageAsset?: ResolvePageAsset;
     /**
-     * Session-page publisher -- the hosted view of the rendered page. Bound, the preview
-     * tool mints one grant after the page lands and attaches the URL beside the path.
-     * Omitted, the result carries the page path alone.
+     * Session-page publisher factory -- the hosted view of the rendered page. The factory
+     * binds one analysis and the auth of the call, like `makeResolver`, thus the mint runs
+     * under the credential of the caller. Bound, the preview tool builds the publisher over
+     * the scope of the call, mints one grant after the page lands, and attaches the URL
+     * beside the path. Omitted, the result carries the page path alone.
      */
-    readonly sessionPages?: SessionPagePublisher;
+    readonly makeSessionPages?: MakeSessionPagePublisher;
     /**
      * Page-URL formation of the eyes -- the URL that one look opens. A composition whose
-     * browser cannot reach the workspace tree binds a resolver that names a served URL.
-     * Omitted, the eyes tool navigates through a `file://` URL of the page path.
+     * browser cannot reach the workspace tree binds a resolver that names a served URL, and
+     * the args carry the auth of the tool call beside the page identity. Omitted, the eyes
+     * tool navigates through a `file://` URL of the page path.
      */
     readonly resolvePageUrl?: ResolvePageUrl;
     /** Operational logging seam; omitted falls back to no-op. */

package/dist/agents/report-session-agent.js

@@ -39,7 +39,7 @@ const REPORT_SESSION_MAX_ITERATIONS = 75;
 /** Build the report `AgentDefinition` with every tool bound to its deps. */
 export function createReportSessionAgent(deps) {
     const { model, pool, embedding, workspaceFs, gateway, resolveWorkspaceRoot, store, threads, chrome, eyes, makeResolver, resolvePageAsset, logger } = deps;
-    const { derivations, sandboxClient, runAuthorizer, sessionPages, resolvePageUrl } = deps;
+    const { derivations, sandboxClient, runAuthorizer, makeSessionPages, resolvePageUrl } = deps;
     const authoring = createReportAuthoringTools(gateway);
     const tools = [
         // The read surface toward the analysis. It roams the tree read-only.
@@ -83,7 +83,7 @@ export function createReportSessionAgent(deps) {
             resolveWorkspaceRoot,
             ...(makeResolver ? { makeResolver } : {}),
             ...(resolvePageAsset ? { resolvePageAsset } : {}),
-            ...(sessionPages ? { sessionPages } : {}),
+            ...(makeSessionPages ? { makeSessionPages } : {}),
             ...(logger ? { logger } : {}),
         }),
         // The eyes tool. It opens the rendered page in headless Chrome.

package/dist/index.d.ts

@@ -36,7 +36,7 @@ export type { ProvenanceCollector } from "./provenance/collector.js";
 export { UnavailablePreviewPublisher } from "./tools/report/preview-publisher.js";
 export type { PreviewPublisher, PreviewMintResult } from "./tools/report/preview-publisher.js";
 export { UnavailableSessionPagePublisher } from "./tools/report-session/session-page-publisher.js";
-export type { SessionPagePublisher, SessionPageMintResult } from "./tools/report-session/session-page-publisher.js";
+export type { MakeSessionPagePublisher, SessionPagePublisher, SessionPageMintResult } from "./tools/report-session/session-page-publisher.js";
 export type { ResolvePageUrl, SessionPageAccess } from "./tools/report-session/index.js";
 export { createDbosRunLauncher } from "./execution/dbos-run-launcher.js";
 export type { RunLauncher, LaunchOptions } from "./execution/run-launcher.js";

package/dist/index.js

@@ -44,8 +44,10 @@ export { createNoopArtifactRegistry } from "./execution/noop-artifact-registry.j
 export { UnavailablePreviewPublisher } from "./tools/report/preview-publisher.js";
 // Seam: the hosted view of a report-session page. A managed host serves the URL space
 // `report-sessions/{analysisId}/{threadId}` and mints access through its own publisher,
-// thus the seam belongs on the front door. The URL seam of the eyes rides beside it: a
-// host whose browser cannot reach the workspace tree binds a served URL for the look.
+// thus the seam belongs on the front door. Both seams bind per call over the auth of the
+// tool call, thus a host mints under the credential of the caller and holds no ambient
+// state. The URL seam of the eyes rides beside the publisher factory: a host whose
+// browser cannot reach the workspace tree binds a served URL for the look.
 export { UnavailableSessionPagePublisher } from "./tools/report-session/session-page-publisher.js";
 // Run launching.
 export { createDbosRunLauncher } from "./execution/dbos-run-launcher.js";

package/dist/runtime/assemble.d.ts

@@ -32,7 +32,7 @@ import { type CitationResolverConfig } from "../citations/resolve.js";
 import type { CitationResolver } from "../citations/types.js";
 import type { AuthContext } from "../auth/types.js";
 import type { ReferenceResolver } from "../report-model/reference-resolver.js";
-import type { ResolvePageAsset, ResolvePageUrl, SessionPagePublisher } from "../tools/report-session/index.js";
+import type { MakeSessionPagePublisher, ResolvePageAsset, ResolvePageUrl } from "../tools/report-session/index.js";
 /** Registered child sandbox-step callable the parent's child dispatch closes over. */
 export type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxStepResult>;
 /**
@@ -134,15 +134,18 @@ export interface CoreRuntimeDeps {
     readonly resolveReportPageAsset?: ResolvePageAsset;
     /**
      * The hosted view of a report-session page. A managed host that serves the session URL
-     * space binds its publisher here, and the preview tool of the report agent then attaches
-     * the minted URL beside the page path. Absent, the tool attaches nothing and the page
-     * path stays the whole result, which is the whole local path.
+     * space binds its publisher factory here, and the preview tool of the report agent then
+     * attaches the minted URL beside the page path. The factory binds one analysis and the
+     * auth of the tool call, like `makeReportReferenceResolver`, thus a host that mints under
+     * the credential of the caller binds it with no ambient state. Absent, the tool attaches
+     * nothing and the page path stays the whole result, which is the whole local path.
      */
-    readonly sessionPagePublisher?: SessionPagePublisher;
+    readonly makeSessionPagePublisher?: MakeSessionPagePublisher;
     /**
      * The page-URL formation of the report-session eyes. A managed host whose browser cannot
-     * reach the workspace tree binds a resolver that names a served URL for the look. Absent,
-     * the eyes tool navigates through a `file://` URL of the page path.
+     * reach the workspace tree binds a resolver that names a served URL for the look, and the
+     * args carry the auth of the tool call beside the page identity. Absent, the eyes tool
+     * navigates through a `file://` URL of the page path.
      */
     readonly resolveReportPageUrl?: ResolvePageUrl;
     /**

package/dist/runtime/assemble.js

@@ -164,7 +164,7 @@ export function assembleCoreRuntime(deps) {
         makeResolver: makeReportResolver,
         ...(eyes ? { eyes } : {}),
         ...(deps.resolveReportPageAsset ? { resolvePageAsset: deps.resolveReportPageAsset } : {}),
-        ...(deps.sessionPagePublisher ? { sessionPages: deps.sessionPagePublisher } : {}),
+        ...(deps.makeSessionPagePublisher ? { makeSessionPages: deps.makeSessionPagePublisher } : {}),
         ...(deps.resolveReportPageUrl ? { resolvePageUrl: deps.resolveReportPageUrl } : {}),
         ...(conversation.logger ? { logger: conversation.logger } : {}),
     });

package/dist/tools/report-session/examine-page.d.ts

@@ -45,6 +45,7 @@
  * and no outcome would ever arrive.
  */
 import { z } from "zod";
+import type { AuthContext } from "../../auth/types.js";
 import { type ChromeConfig } from "../../lib/chrome.js";
 import { type AcquireEyes } from "../../lib/eyes.js";
 import { type Logger } from "../../lib/logger.js";
@@ -56,11 +57,14 @@ export type { CapturePage, FailedRequest, PageCapture };
 /**
  * The URL formation of one look. It maps the page of the thread onto the URL that the browser opens.
  * A composition whose browser cannot reach the workspace tree binds a resolver that names a served URL.
+ * The args carry the auth of the tool call beside the page identity, thus a realization mints the URL
+ * under the credential of the caller and holds no ambient state.
  */
 export type ResolvePageUrl = (args: {
     pagePath: string;
     analysisId: string;
     threadId: string;
+    auth: AuthContext;
 }) => Promise<string>;
 /** The empty input. The tool examines the current page of the thread, thus it needs no field. */
 declare const examinePageInput: z.ZodObject<{}, z.core.$strip>;

package/dist/tools/report-session/examine-page.js

@@ -276,7 +276,10 @@ export function createExaminePageTool(deps) {
             // becomes a typed outcome and the look never starts.
             let url;
             try {
-                url = deps.resolvePageUrl !== undefined ? await deps.resolvePageUrl({ pagePath, analysisId, threadId }) : pathToFileURL(pagePath).href;
+                url =
+                    deps.resolvePageUrl !== undefined
+                        ? await deps.resolvePageUrl({ pagePath, analysisId, threadId, auth: ctx.session.auth })
+                        : pathToFileURL(pagePath).href;
             }
             catch (cause) {
                 logger.warn("the page URL did not resolve", { threadId, analysisId, ...defaultErrorFields(cause) });

package/dist/tools/report-session/index.d.ts

@@ -7,7 +7,7 @@
  */
 export { createPreviewReportTool, type PreviewReportInput, type PreviewReportResult, type PreviewReportToolDeps, type ResolvePageAsset, type SessionPageAccess, } from "./preview-report.js";
 export { createExaminePageTool, type CapturePage, type ExaminePageInput, type ExaminePageResult, type ExaminePageToolDeps, type FailedRequest, type PageCapture, type ResolvePageUrl, } from "./examine-page.js";
-export { describeSessionPageMintFailure, UnavailableSessionPagePublisher, type SessionPageMintFailure, type SessionPageMintResult, type SessionPagePublisher, } from "./session-page-publisher.js";
+export { describeSessionPageMintFailure, UnavailableSessionPagePublisher, type MakeSessionPagePublisher, type SessionPageMintFailure, type SessionPageMintResult, type SessionPagePublisher, } from "./session-page-publisher.js";
 export { createRecordVersionTool, type RecordVersionInput, type RecordVersionResult, type RecordVersionToolDeps } from "./record-version.js";
 export { createDeriveTableTool, type DeriveTableInput, type DeriveTableResult, type DeriveTableToolDeps } from "./derive-table.js";
 export { createListPinnedArtifactsTool, type ListPinnedArtifactsInput, type ListPinnedArtifactsResult, type ListPinnedArtifactsToolDeps, type PinnedArtifact, type PinnedCitation, } from "./list-artifacts.js";

package/dist/tools/report-session/preview-report.d.ts

@@ -16,11 +16,12 @@
  * namespace belongs to this path alone, thus the tool never writes under the old `previews/` or `reports/`
  * trees. The result carries the absolute page path, thus a local host shows the page with no seam.
  *
- * A hosted view rides the same result. When the composition binds the session-page publisher, the tool
- * mints one grant after the page lands, and the `rendered` arm carries the URL of the URL space
- * `report-sessions/{analysisId}/{threadId}` (`contracts/content-url.ts`) beside the path. A refused mint
- * rides the arm as data, and the page path stays good — a broken grant surface never costs the render. An
- * unbound publisher changes nothing: the arm carries no access field, and a local host opens the file.
+ * A hosted view rides the same result. When the composition binds the session-page factory, the tool
+ * builds the publisher over the scope of the call, mints one grant after the page lands, and the
+ * `rendered` arm carries the URL of the URL space `report-sessions/{analysisId}/{threadId}`
+ * (`contracts/content-url.ts`) beside the path. A refused mint rides the arm as data, and the page path
+ * stays good — a broken grant surface never costs the render. An unbound factory changes nothing: the
+ * arm carries no access field, and a local host opens the file.
  *
  * Each degraded condition is a typed outcome in the ok channel: a session refusal, a gap list, a resolver
  * absence, an unresolvable root at resolver construction, an unresolved reference, a bridge mismatch, a
@@ -43,7 +44,7 @@ import { type BridgeMismatch } from "../../report-render/value-bridge.js";
 import type { RenderProblem } from "../../report-render/types.js";
 import { type Tool } from "../define-tool.js";
 import { type ReportSessionStateGateway, type SessionRefusal } from "../report-authoring/authoring-tools.js";
-import { type SessionPagePublisher } from "./session-page-publisher.js";
+import { type MakeSessionPagePublisher } from "./session-page-publisher.js";
 /** The empty input. The tool renders the current draft of the thread, thus it needs no field. */
 declare const previewReportInput: z.ZodObject<{}, z.core.$strip>;
 export type PreviewReportInput = z.infer<typeof previewReportInput>;
@@ -118,9 +119,11 @@ export type ResolvePageAsset = (specifier: string) => string;
  * harness. An embedder that ships the asset bytes packed, for example a compiled single-file binary with no
  * `node_modules` tree, materializes them to disk and binds its own lookup here.
  *
- * `sessionPages` is optional, because a local host opens the page path itself. Bound, the tool mints one
- * grant after the page lands and attaches the URL beside the path. A refused mint rides the `rendered` arm
- * as data, and it never fails the render.
+ * `makeSessionPages` is optional, because a local host opens the page path itself. It binds one analysis
+ * and the auth of the call, like `makeResolver`, thus a realization mints under the credential of the
+ * caller. Bound, the tool builds the publisher over the scope of the call, mints one grant after the page
+ * lands, and attaches the URL beside the path. A refused mint rides the `rendered` arm as data, and it
+ * never fails the render.
  */
 export interface PreviewReportToolDeps {
     readonly gateway: ReportSessionStateGateway;
@@ -130,7 +133,7 @@ export interface PreviewReportToolDeps {
     }) => ReferenceResolver;
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
     readonly resolvePageAsset?: ResolvePageAsset;
-    readonly sessionPages?: SessionPagePublisher;
+    readonly makeSessionPages?: MakeSessionPagePublisher;
     readonly logger?: Logger;
 }
 /**

package/dist/tools/report-session/preview-report.js

@@ -16,11 +16,12 @@
  * namespace belongs to this path alone, thus the tool never writes under the old `previews/` or `reports/`
  * trees. The result carries the absolute page path, thus a local host shows the page with no seam.
  *
- * A hosted view rides the same result. When the composition binds the session-page publisher, the tool
- * mints one grant after the page lands, and the `rendered` arm carries the URL of the URL space
- * `report-sessions/{analysisId}/{threadId}` (`contracts/content-url.ts`) beside the path. A refused mint
- * rides the arm as data, and the page path stays good — a broken grant surface never costs the render. An
- * unbound publisher changes nothing: the arm carries no access field, and a local host opens the file.
+ * A hosted view rides the same result. When the composition binds the session-page factory, the tool
+ * builds the publisher over the scope of the call, mints one grant after the page lands, and the
+ * `rendered` arm carries the URL of the URL space `report-sessions/{analysisId}/{threadId}`
+ * (`contracts/content-url.ts`) beside the path. A refused mint rides the arm as data, and the page path
+ * stays good — a broken grant surface never costs the render. An unbound factory changes nothing: the
+ * arm carries no access field, and a local host opens the file.
  *
  * Each degraded condition is a typed outcome in the ok channel: a session refusal, a gap list, a resolver
  * absence, an unresolvable root at resolver construction, an unresolved reference, a bridge mismatch, a
@@ -342,18 +343,20 @@ async function sweepAssets(assetsDir, staged, logger) {
 /**
  * Mint the hosted view of the page that landed.
  *
- * An absent publisher gives no grant, and the arm carries no access field — the page path stays the whole
- * local contract. A refusal and a thrown realization each become the not-granted arm, thus a broken grant
- * surface never costs the render. The URL spells through `buildReportSessionUrl`, thus the formula lives in
- * the contract and the seam gives the content-server base alone.
+ * An absent factory gives no grant, and the arm carries no access field — the page path stays the whole
+ * local contract. The tool builds the publisher over the scope of the call, thus the mint runs under the
+ * auth of the caller. A refusal, a thrown construction, and a thrown realization each become the
+ * not-granted arm, thus a broken grant surface never costs the render. The URL spells through
+ * `buildReportSessionUrl`, thus the formula lives in the contract and the seam gives the content-server
+ * base alone.
  */
-async function mintAccess(publisher, analysisId, threadId, logger) {
-    if (publisher === undefined) {
+async function mintAccess(makeSessionPages, analysisId, threadId, auth, logger) {
+    if (makeSessionPages === undefined) {
         return undefined;
     }
     let minted;
     try {
-        minted = await publisher.mintSessionPageAccess(analysisId, threadId);
+        minted = await makeSessionPages({ analysisId, auth }).mintSessionPageAccess(threadId);
     }
     catch (cause) {
         logger.warn("the session-page mint threw", { threadId, analysisId, ...defaultErrorFields(cause) });
@@ -472,7 +475,7 @@ export function createPreviewReportTool(deps) {
                 logger.warn("the rendered hash did not stamp", { threadId, analysisId, detail });
                 return ok({ outcome: "stamp-failed", pagePath: written.value, detail });
             }
-            const access = await mintAccess(deps.sessionPages, analysisId, threadId, logger);
+            const access = await mintAccess(deps.makeSessionPages, analysisId, threadId, ctx.session.auth, logger);
             return ok({ outcome: "rendered", pagePath: written.value, ...(access !== undefined ? { access } : {}) });
         },
     });

package/dist/tools/report-session/session-page-publisher.d.ts

@@ -7,10 +7,14 @@
  * `report-sessions/{analysisId}/{threadId}` (`contracts/content-url.ts`). That mint hides behind this
  * one method.
  *
- * The managed realization owns the grant mint and its client. The local default
- * (`UnavailableSessionPagePublisher`) returns not-ok, thus the preview tool attaches no URL and the
- * render still lands — the page path stays the whole local contract.
+ * The managed realization owns the grant mint and its client. A mint runs under the credential of the
+ * tool call, thus the composition binds a factory and the preview tool builds the publisher over the
+ * scope of the call — exactly as it builds the reference resolver. A boot-time singleton could not
+ * carry that credential, and a host that bans ambient state could not bind one at all. The local
+ * default (`UnavailableSessionPagePublisher`) returns not-ok, thus the preview tool attaches no URL
+ * and the render still lands — the page path stays the whole local contract.
  */
+import type { AuthContext } from "../../auth/types.js";
 export type SessionPageMintResult = {
     ok: true;
     data: {
@@ -40,16 +44,25 @@ export type SessionPageMintFailure = Extract<SessionPageMintResult, {
 export declare function describeSessionPageMintFailure(failure: SessionPageMintFailure): string;
 export interface SessionPagePublisher {
     /**
-     * Mint the access grant of one session page. `baseUrl` is the base URL of the content server, with
-     * no res path — the caller spells the whole URL through `buildReportSessionUrl`, thus the formula
-     * lives in the contract and never in a realization.
+     * Mint the access grant of one session page. The publisher binds the analysis, thus the mint takes
+     * the thread id alone. `baseUrl` is the base URL of the content server, with no res path — the
+     * caller spells the whole URL through `buildReportSessionUrl`, thus the formula lives in the
+     * contract and never in a realization.
      */
-    mintSessionPageAccess(analysisId: string, threadId: string): Promise<SessionPageMintResult>;
+    mintSessionPageAccess(threadId: string): Promise<SessionPageMintResult>;
 }
+/**
+ * The per-call construction of the publisher. The factory binds one analysis and the auth of the tool
+ * call, thus a realization mints under the credential of the caller and holds no ambient state.
+ */
+export type MakeSessionPagePublisher = (scope: {
+    analysisId: string;
+    auth: AuthContext;
+}) => SessionPagePublisher;
 /**
  * Local default — no hosted view of a session page. Returns not-ok, thus the preview tool carries the
  * refusal as data and the page path stays the whole result.
  */
 export declare class UnavailableSessionPagePublisher implements SessionPagePublisher {
-    mintSessionPageAccess(_analysisId: string, _threadId: string): Promise<SessionPageMintResult>;
+    mintSessionPageAccess(_threadId: string): Promise<SessionPageMintResult>;
 }

package/dist/tools/report-session/session-page-publisher.js

@@ -7,9 +7,12 @@
  * `report-sessions/{analysisId}/{threadId}` (`contracts/content-url.ts`). That mint hides behind this
  * one method.
  *
- * The managed realization owns the grant mint and its client. The local default
- * (`UnavailableSessionPagePublisher`) returns not-ok, thus the preview tool attaches no URL and the
- * render still lands — the page path stays the whole local contract.
+ * The managed realization owns the grant mint and its client. A mint runs under the credential of the
+ * tool call, thus the composition binds a factory and the preview tool builds the publisher over the
+ * scope of the call — exactly as it builds the reference resolver. A boot-time singleton could not
+ * carry that credential, and a host that bans ambient state could not bind one at all. The local
+ * default (`UnavailableSessionPagePublisher`) returns not-ok, thus the preview tool attaches no URL
+ * and the render still lands — the page path stays the whole local contract.
  */
 /**
  * Renders a failed mint as the line an agent reads back from the preview tool.
@@ -33,7 +36,7 @@ export function describeSessionPageMintFailure(failure) {
  * refusal as data and the page path stays the whole result.
  */
 export class UnavailableSessionPagePublisher {
-    async mintSessionPageAccess(_analysisId, _threadId) {
+    async mintSessionPageAccess(_threadId) {
         return {
             ok: false,
             error: { message: "the hosted view of a session page is unavailable in this environment" },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.22.0",
+    "version": "0.22.1",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",