@re-cinq/floor-station 0.1.1 → 0.1.4

package/dist/floor.d.ts

@@ -1,49 +1,22 @@
-export interface Claimed {
-    id: string;
-    name: string;
-    payload: {
-        visitId: string;
-    };
-}
-export type BriefNeed = {
-    name: string;
-    kind: "value";
-    value: string;
-} | {
-    name: string;
-    kind: "file";
-    path: string;
-    url: string;
-} | {
-    name: string;
-    kind: "git";
-    path: string;
-    repoUrl: string;
-    ref: string;
-};
-export interface VisitBrief {
-    visitId: string;
-    iteration: number;
-    token: string;
-    deadlineMinutes: number;
-    needs: BriefNeed[];
-}
+import type { ClaimedEvent, Report, VisitBrief } from "@re-cinq/floor-contracts";
+export type { BriefNeed, VisitBrief } from "@re-cinq/floor-contracts";
+export type Claimed = ClaimedEvent;
 export interface FloorAccess {
     floorUrl: string;
     token: string;
 }
 export declare class Floor {
     private readonly access;
+    private readonly client;
     constructor(access: FloorAccess);
     claim(tags: string[], limit: number): Promise<Claimed[]>;
     ack(eventId: string): Promise<void>;
     fail(eventId: string, error: string): Promise<void>;
-    /** Null when the visit is already done: a dispatch delivered again after its visit reported. */
+    /** Null when the visit is already done, or gone: a dispatch delivered again after its visit reported. */
     brief(visitId: string): Promise<VisitBrief | null>;
-    read(url: string, visitToken: string): Promise<Buffer>;
-    store(bytes: Buffer, visitToken: string): Promise<string>;
-    record(visitId: string, body: unknown, visitToken: string): Promise<void>;
-    report(visitId: string, report: unknown, worker: string): Promise<void>;
-    private send;
-    private request;
+    read(url: string, token: string): Promise<Buffer>;
+    store(bytes: Buffer, token: string): Promise<string>;
+    record(visitId: string, body: unknown, token: string): Promise<void>;
+    report(visitId: string, report: Report, worker: string): Promise<void>;
+    private visit;
 }

package/dist/floor.js

@@ -1,59 +1,46 @@
-// The floor, as a station reaches it: over HTTP and nothing else. The service token claims and acks; everything about one visit goes under that visit's own token.
-const REQUEST_TIMEOUT_MS = 30_000;
-const HTTP_NO_CONTENT = 204;
-const HTTP_CONFLICT = 409;
+// The floor, as a station reaches it: the shared client, with the service token claiming and acking and each visit's own token doing everything about that visit.
+import { createFloorClient, createVisitClient, serviceToken, visitToken } from "@re-cinq/floor-client";
 export class Floor {
     access;
+    client;
     constructor(access) {
         this.access = access;
+        this.client = createFloorClient({ url: access.floorUrl, token: serviceToken(access.token) });
     }
     async claim(tags, limit) {
-        const response = await this.send("/events/claim", { method: "POST", body: JSON.stringify({ tags, limit }) });
-        return response.status === HTTP_NO_CONTENT ? [] : (await response.json());
+        return this.client.events.claim({ tags, limit });
     }
     async ack(eventId) {
-        await this.send(`/events/${eventId}/ack`, { method: "POST" });
+        await this.client.events.ack(eventId);
     }
     async fail(eventId, error) {
-        await this.send(`/events/${eventId}/fail`, { method: "POST", body: JSON.stringify({ error, permanent: false }) });
+        await this.client.events.fail(eventId, error);
     }
-    /** Null when the visit is already done: a dispatch delivered again after its visit reported. */
+    /** Null when the visit is already done, or gone: a dispatch delivered again after its visit reported. */
     async brief(visitId) {
-        const response = await this.request(`/station-runs/${visitId}/brief`, {}, this.access.token);
-        if (response.status === HTTP_CONFLICT)
-            return null;
-        return (await accepted(response)).json();
+        const outcome = await this.client.stationRuns.brief(visitId);
+        return outcome.kind === "brief" ? outcome.brief : null;
     }
     // The brief gives a file's address as a pod would reach it. A station reaches the floor its own way, so only the path is taken from it.
-    async read(url, visitToken) {
-        const response = await accepted(await this.request(new URL(url).pathname, {}, visitToken));
-        return Buffer.from(await response.arrayBuffer());
-    }
-    async store(bytes, visitToken) {
-        const response = await this.request("/blobs", { method: "POST", body: new Uint8Array(bytes), headers: { "content-type": "application/octet-stream" } }, visitToken);
-        const stored = (await (await accepted(response)).json());
+    async read(url, token) {
+        const stored = await this.visit("", token).readBlob(url);
+        if (!stored)
+            throw new Error(`the floor has no bytes at "${url}"`);
+        return Buffer.from(stored.bytes);
+    }
+    async store(bytes, token) {
+        const stored = await this.visit("", token).storeBlob(new Uint8Array(bytes));
         return stored.hash;
     }
-    async record(visitId, body, visitToken) {
-        const records = [{ kind: "llm_call", body, occurredAt: new Date().toISOString() }];
-        await accepted(await this.request(`/station-runs/${visitId}/records`, { method: "POST", body: JSON.stringify({ records }) }, visitToken));
+    async record(visitId, body, token) {
+        await this.visit(visitId, token).append([{ kind: "llm_call", body, occurredAt: new Date() }]);
     }
     // Deduplicated on the visit, so posting it again after a lost answer reports once.
     async report(visitId, report, worker) {
-        const event = { name: "station_run.reported", payload: { visitId, worker, report }, dedupeKey: `station_run.reported:${visitId}` };
-        await this.send("/events", { method: "POST", body: JSON.stringify(event) });
-    }
-    async send(path, init) {
-        return accepted(await this.request(path, init, this.access.token));
+        await this.visit(visitId, this.access.token).report({ report, worker });
     }
-    request(path, init, token) {
-        const headers = { "content-type": "application/json", ...init.headers, authorization: `Bearer ${token}` };
-        return fetch(`${this.access.floorUrl}${path}`, { ...init, headers, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+    visit(visitId, token) {
+        return createVisitClient({ url: this.access.floorUrl, token: visitToken(token), visitId });
     }
 }
-async function accepted(response) {
-    if (response.ok)
-        return response;
-    throw new Error(`the floor answered ${response.status} to ${response.url}: ${await response.text()}`);
-}
 //# sourceMappingURL=floor.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@re-cinq/floor-station",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "The floor's service station SDK: defineStation(name, handle) claims the station's dispatches from a floor's queue, hands each to one function as a brief, and posts what it returns as the visit's report. A station needs only a way out to the floor; the floor never calls it.",
   "license": "Apache-2.0",
   "repository": {
@@ -44,6 +44,10 @@
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   },
+  "dependencies": {
+    "@re-cinq/floor-client": "0.1.4",
+    "@re-cinq/floor-contracts": "0.1.4"
+  },
   "devDependencies": {
     "@types/node": "^22.20.1",
     "@vitest/coverage-v8": "^5.0.0",