@dxos/edge-client 0.9.0 → 0.9.1-staging.ee54ba693a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/edge-client",
-  "version": "0.9.0",
+  "version": "0.9.1-staging.ee54ba693a",
   "description": "EDGE Client",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -28,6 +28,11 @@
       "types": "./dist/types/src/edge-ws-muxer.d.ts",
       "default": "./dist/lib/neutral/edge-ws-muxer.mjs"
     },
+    "./service": {
+      "source": "./src/service/index.ts",
+      "types": "./dist/types/src/service/index.d.ts",
+      "default": "./dist/lib/neutral/service/index.mjs"
+    },
     "./testing": {
       "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
@@ -41,29 +46,29 @@
     "README.md"
   ],
   "dependencies": {
-    "@effect/platform": "0.96.1",
+    "@effect/platform": "0.96.2",
     "@opentelemetry/api": "^1.9.1",
     "isomorphic-ws": "^5.0.0",
     "ws": "^8.17.1",
-    "@dxos/async": "0.9.0",
-    "@dxos/context": "0.9.0",
-    "@dxos/credentials": "0.9.0",
-    "@dxos/crypto": "0.9.0",
-    "@dxos/effect": "0.9.0",
-    "@dxos/errors": "0.9.0",
-    "@dxos/invariant": "0.9.0",
-    "@dxos/keyring": "0.9.0",
-    "@dxos/keys": "0.9.0",
-    "@dxos/log": "0.9.0",
-    "@dxos/util": "0.9.0",
-    "@dxos/node-std": "0.9.0",
-    "@dxos/protocols": "0.9.0"
+    "@dxos/async": "0.9.1-staging.ee54ba693a",
+    "@dxos/context": "0.9.1-staging.ee54ba693a",
+    "@dxos/crypto": "0.9.1-staging.ee54ba693a",
+    "@dxos/effect": "0.9.1-staging.ee54ba693a",
+    "@dxos/invariant": "0.9.1-staging.ee54ba693a",
+    "@dxos/credentials": "0.9.1-staging.ee54ba693a",
+    "@dxos/errors": "0.9.1-staging.ee54ba693a",
+    "@dxos/keyring": "0.9.1-staging.ee54ba693a",
+    "@dxos/keys": "0.9.1-staging.ee54ba693a",
+    "@dxos/log": "0.9.1-staging.ee54ba693a",
+    "@dxos/node-std": "0.9.1-staging.ee54ba693a",
+    "@dxos/util": "0.9.1-staging.ee54ba693a",
+    "@dxos/protocols": "0.9.1-staging.ee54ba693a"
   },
   "devDependencies": {
-    "@dxos/test-utils": "0.9.0"
+    "@dxos/test-utils": "0.9.1-staging.ee54ba693a"
   },
   "peerDependencies": {
-    "effect": "3.21.3"
+    "effect": "3.21.4"
   },
   "publishConfig": {
     "access": "public"

package/src/auth.ts

@@ -2,11 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { createCredential, signPresentation } from '@dxos/credentials';
+import { createCredential, createDidFromIdentityKey, signPresentation } from '@dxos/credentials';
 import { type Signer } from '@dxos/crypto';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
-import { PublicKey } from '@dxos/keys';
+import { IdentityDid, PublicKey } from '@dxos/keys';
 import { type Chain, type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 
 import type { EdgeIdentity } from './edge-identity';
@@ -16,7 +16,7 @@ import type { EdgeIdentity } from './edge-identity';
  */
 export const createDeviceEdgeIdentity = async (signer: Signer, key: PublicKey): Promise<EdgeIdentity> => {
   return {
-    identityKey: key.toHex(),
+    identityDid: await createDidFromIdentityKey(key),
     peerKey: key.toHex(),
     presentCredentials: async ({ challenge }) => {
       return signPresentation({
@@ -68,7 +68,7 @@ export const createChainEdgeIdentity = async (
         ];
 
   return {
-    identityKey: identityKey.toHex(),
+    identityDid: await createDidFromIdentityKey(identityKey),
     peerKey: peerKey.toHex(),
     presentCredentials: async ({ challenge }) => {
       // TODO: make chain required after device invitation flow update release
@@ -126,10 +126,10 @@ export const createTestHaloEdgeIdentity = async (
 };
 
 export const createStubEdgeIdentity = (): EdgeIdentity => {
-  const identityKey = PublicKey.random();
   const deviceKey = PublicKey.random();
   return {
-    identityKey: identityKey.toHex(),
+    // Random placeholder DID — the stub never authenticates or connects; a real identity replaces it.
+    identityDid: IdentityDid.random(),
     peerKey: deviceKey.toHex(),
     presentCredentials: async () => {
       throw new Error('Stub identity does not support authentication.');

package/src/base-http-client.ts

@@ -71,7 +71,7 @@ export abstract class BaseHttpClient {
   }
 
   setIdentity(identity: EdgeIdentity): void {
-    if (this._edgeIdentity?.identityKey !== identity.identityKey || this._edgeIdentity?.peerKey !== identity.peerKey) {
+    if (this._edgeIdentity?.identityDid !== identity.identityDid || this._edgeIdentity?.peerKey !== identity.peerKey) {
       this._edgeIdentity = identity;
       this._authHeader = undefined;
     }

package/src/browser-rendering.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import * as Schema from 'effect/Schema';
+
+import { type EdgeHttpClient } from './edge-http-client';
+
+/** Request body for EDGE `/ai/browser-rendering/markdown` (ai-service Browser Run markdown quick action). */
+export const MarkdownRequest = Schema.Struct({
+  url: Schema.optional(Schema.String),
+  html: Schema.optional(Schema.String),
+  gotoOptions: Schema.optional(
+    Schema.Struct({
+      waitUntil: Schema.optional(Schema.Literal('load', 'domcontentloaded', 'networkidle0', 'networkidle2')),
+      timeout: Schema.optional(Schema.Number),
+    }),
+  ),
+  rejectRequestPattern: Schema.optional(Schema.Array(Schema.String)),
+  userAgent: Schema.optional(Schema.String),
+  waitForSelector: Schema.optional(Schema.String),
+});
+
+export type MarkdownRequest = Schema.Schema.Type<typeof MarkdownRequest>;
+
+/** JSON body returned by Cloudflare Browser Run markdown quick action. */
+export const MarkdownResponse = Schema.Struct({
+  success: Schema.Boolean,
+  result: Schema.String,
+});
+
+export type MarkdownResponse = Schema.Schema.Type<typeof MarkdownResponse>;
+
+/** Authenticated EDGE HTTP client for operation handlers (e.g. browser markdown fetch). */
+export class EdgeHttpClientService extends Context.Tag('@dxos/edge-client/EdgeHttpClientService')<
+  EdgeHttpClientService,
+  EdgeHttpClient
+>() {}

package/src/edge-ai-http-client.test.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { patchAnthropicMessagesRequestBody } from './edge-ai-http-client';
+
+describe('patchAnthropicMessagesRequestBody', () => {
+  test('adds eager_input_streaming to user-defined tools', ({ expect }) => {
+    const body = JSON.stringify({
+      model: 'claude-sonnet-4-6',
+      stream: true,
+      tools: [
+        {
+          name: 'delegate-task',
+          description: 'Delegate work',
+          input_schema: { type: 'object', properties: { title: { type: 'string' } } },
+        },
+        {
+          name: 'bash',
+          type: 'bash_20250124',
+        },
+      ],
+    });
+
+    const patched = JSON.parse(patchAnthropicMessagesRequestBody(body) as string);
+
+    expect(patched.tools[0]).toMatchObject({ eager_input_streaming: true });
+    expect(patched.tools[1]).not.toHaveProperty('eager_input_streaming');
+  });
+
+  test('leaves non-json bodies unchanged', ({ expect }) => {
+    const body = 'not-json';
+    expect(patchAnthropicMessagesRequestBody(body)).toBe(body);
+  });
+});

package/src/edge-ai-http-client.ts

@@ -31,11 +31,72 @@ export class ByokError extends BaseError.extend('ByokError', 'BYOK authenticatio
   }
 }
 
+/**
+ * Thrown by {@link EdgeAiHttpClient} when EDGE rejects an AI request with 429 because the
+ * authenticated profile exceeded a metering limit. Wrapped as the `cause` of an
+ * {@link HttpClientError.ResponseError} so it survives `@effect/ai`'s error mapping.
+ */
+export class UsageQuotaExceededError extends BaseError.extend('UsageQuotaExceededError', 'Usage quota exceeded') {}
+
 /**
  * Copy pasted from https://github.com/Effect-TS/effect/blob/main/packages/platform/src/internal/fetchHttpClient.ts
  */
 export const requestInitTagKey = '@effect/platform/FetchHttpClient/FetchOptions';
 
+type AnthropicMessagesPayload = {
+  tools?: ReadonlyArray<Record<string, unknown>>;
+};
+
+const isUserDefinedAnthropicTool = (tool: Record<string, unknown>): boolean =>
+  tool.input_schema != null && typeof tool.input_schema === 'object';
+
+/**
+ * Enables Anthropic fine-grained tool input streaming for client-defined tools.
+ * Provider tools (bash, web_search, etc.) are left unchanged.
+ */
+export const patchAnthropicMessagesRequestBody = (body: BodyInit | undefined): BodyInit | undefined => {
+  if (body == null) {
+    return body;
+  }
+
+  const decodeBody = (): string | undefined => {
+    if (typeof body === 'string') {
+      return body;
+    }
+    if (body instanceof Uint8Array) {
+      return new TextDecoder().decode(body);
+    }
+    return undefined;
+  };
+
+  const text = decodeBody();
+  if (text == null) {
+    return body;
+  }
+
+  try {
+    const payload = JSON.parse(text) as AnthropicMessagesPayload;
+    if (!Array.isArray(payload.tools)) {
+      return body;
+    }
+
+    payload.tools = payload.tools.map((tool) =>
+      isUserDefinedAnthropicTool(tool) ? { ...tool, eager_input_streaming: true } : tool,
+    );
+
+    const patched = JSON.stringify(payload);
+    return typeof body === 'string' ? patched : new TextEncoder().encode(patched);
+  } catch {
+    return body;
+  }
+};
+
+const readStreamBody = (stream: ReadableStream<Uint8Array>): Effect.Effect<string | undefined> =>
+  Effect.promise(async () => {
+    const response = new Response(stream);
+    return await response.text();
+  });
+
 /**
  * An `@effect/platform` {@link HttpClient.HttpClient} that routes requests through the
  * authenticated EDGE AI endpoint via {@link EdgeHttpClient.anthropicAiRequest}, instead of
@@ -67,7 +128,7 @@ export class EdgeAiHttpClient {
                 ...options,
                 method: request.method,
                 headers,
-                body,
+                body: patchAnthropicMessagesRequestBody(body),
                 signal,
               }),
             ),
@@ -107,6 +168,27 @@ export class EdgeAiHttpClient {
                 ),
               );
             }
+            // Platform quota (not BYOK): reserve/commit rejected the request before upstream AI.
+            if (!carriedByok && response.status === 429) {
+              return Effect.tryPromise({
+                try: () => response.clone().json() as Promise<{ error?: { message?: string } } | undefined>,
+                catch: () => undefined,
+              }).pipe(
+                Effect.orElseSucceed(() => undefined),
+                Effect.flatMap((body) =>
+                  Effect.fail(
+                    new HttpClientError.ResponseError({
+                      request,
+                      response: httpResponse,
+                      reason: 'StatusCode',
+                      cause: new UsageQuotaExceededError({
+                        message: body?.error?.message,
+                      }),
+                    }),
+                  ),
+                ),
+              );
+            }
             return Effect.succeed(httpResponse);
           }),
         );
@@ -118,7 +200,10 @@ export class EdgeAiHttpClient {
         case 'FormData':
           return send(request.body.formData);
         case 'Stream':
-          return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect.flatMap(send));
+          return Stream.toReadableStreamEffect(request.body.stream).pipe(
+            Effect.flatMap((readable) => readStreamBody(readable)),
+            Effect.flatMap((text) => send(text)),
+          );
       }
 
       return send(undefined);

package/src/edge-client.test.ts

@@ -158,7 +158,7 @@ describe('EdgeClient', () => {
 
   const textMessage = (message: string, source?: EdgeIdentity) =>
     protocol.createMessage(TextMessageSchema, {
-      source: source && { peerKey: source.peerKey, identityKey: source.identityKey },
+      source: source && { peerKey: source.peerKey, identityDid: source.identityDid },
       payload: { message },
     });
 

package/src/edge-client.ts

@@ -43,7 +43,8 @@ export type MessengerConfig = {
 export interface EdgeConnection extends Required<Lifecycle> {
   statusChanged: Event<EdgeStatus>;
   get info(): any;
-  get identityKey(): string;
+  /** Identity DID (`did:halo:…`) of the connected identity. */
+  get identityDid(): string;
   get peerKey(): string;
   get isOpen(): boolean;
   get status(): EdgeStatus;
@@ -88,7 +89,7 @@ export class EdgeClient extends Resource implements EdgeConnection {
     return {
       open: this.isOpen,
       status: this.status,
-      identity: this._identity.identityKey,
+      identity: this._identity.identityDid,
       device: this._identity.peerKey,
     };
   }
@@ -108,8 +109,8 @@ export class EdgeClient extends Resource implements EdgeConnection {
     };
   }
 
-  get identityKey() {
-    return this._identity.identityKey;
+  get identityDid() {
+    return this._identity.identityDid;
   }
 
   get peerKey() {
@@ -117,7 +118,7 @@ export class EdgeClient extends Resource implements EdgeConnection {
   }
 
   setIdentity(identity: EdgeIdentity) {
-    if (identity.identityKey !== this._identity.identityKey || identity.peerKey !== this._identity.peerKey) {
+    if (identity.identityDid !== this._identity.identityDid || identity.peerKey !== this._identity.peerKey) {
       log('Edge identity changed', { identity, oldIdentity: this._identity });
       this._identity = identity;
       this._closeCurrentConnection(new EdgeIdentityChangedError());
@@ -139,9 +140,10 @@ export class EdgeClient extends Resource implements EdgeConnection {
       throw new EdgeConnectionClosedError();
     }
 
+    // DX-1059: sources are DID-only; validate against identityDid.
     if (
       message.source &&
-      (message.source.peerKey !== this._identity.peerKey || message.source.identityKey !== this.identityKey)
+      (message.source.peerKey !== this._identity.peerKey || message.source.identityDid !== this.identityDid)
     ) {
       throw new EdgeIdentityChangedError();
     }
@@ -219,7 +221,7 @@ export class EdgeClient extends Resource implements EdgeConnection {
     }
 
     const identity = this._identity;
-    const path = `/ws/${identity.identityKey}/${identity.peerKey}`;
+    const path = `/ws/${identity.identityDid}/${identity.peerKey}`;
     const protocolHeader = this._config.disableAuth ? undefined : await this._createAuthHeader(path);
     if (this._identity !== identity) {
       log('identity changed during auth header request');

package/src/edge-http-client.ts

@@ -11,7 +11,7 @@ import * as Function from 'effect/Function';
 import { type Context } from '@dxos/context';
 import { EffectEx } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
-import { type PublicKey, type SpaceId } from '@dxos/keys';
+import { type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
   type CompleteOAuthRegistrationRequest,
@@ -28,7 +28,6 @@ import {
   type FeedProtocol,
   type GetAgentStatusResponseBody,
   type GetNotarizationResponseBody,
-  type GetPluginVersionsResponseBody,
   type GetPluginsResponseBody,
   type ImportBundleRequest,
   type InitiateOAuthFlowRequest,
@@ -63,6 +62,12 @@ export type EdgeQueryQueueResponse = {
   prevCursor?: string;
 };
 
+export type UploadPluginBundleRequest = {
+  slug: string;
+  version: string;
+  files: { path: string; content: string }[];
+};
+
 export type TriggersDispatcherStatus = {
   isActive: boolean;
   nextCronTaskRunTimestamp?: number;
@@ -112,10 +117,10 @@ export class EdgeHttpClient extends BaseHttpClient {
 
   public getAgentStatus(
     ctx: Context,
-    request: { ownerIdentityKey: PublicKey },
+    request: { ownerIdentityDid: string },
     args?: EdgeHttpCallArgs,
   ): Promise<GetAgentStatusResponseBody> {
-    return this._call(ctx, new URL(`/users/${request.ownerIdentityKey.toHex()}/agent/status`, this.baseUrl), {
+    return this._call(ctx, new URL(`/users/${request.ownerIdentityDid}/agent/status`, this.baseUrl), {
       ...args,
       method: 'GET',
     });
@@ -266,7 +271,10 @@ export class EdgeHttpClient extends BaseHttpClient {
     const formData = new FormData();
     formData.append('name', body.name ?? '');
     formData.append('version', body.version);
-    formData.append('ownerPublicKey', body.ownerPublicKey);
+    // The function owner is the authenticated identity (edge requires ownerUri === presenter DID).
+    // Prefer the connected identity's DID; otherwise use the DID supplied on the request body.
+    const ownerUri = this._edgeIdentity?.identityDid ?? body.ownerUri;
+    formData.append('ownerUri', ownerUri);
     formData.append('entryPoint', body.entryPoint);
     body.runtime && formData.append('runtime', body.runtime);
     for (const [filename, content] of Object.entries(body.assets)) {
@@ -379,14 +387,21 @@ export class EdgeHttpClient extends BaseHttpClient {
     return this._call(ctx, new URL('/registry/plugins', this.baseUrl), { ...args, method: 'GET' });
   }
 
-  public async getRegistryPluginVersions(
+  /**
+   * Uploads a built plugin bundle to the registry's R2-backed hosting. Authenticated
+   * with the caller's hub identity (verifiable presentation) — `setIdentity` must
+   * have been called. Returns the canonical `moduleUrl` (the hosted `manifest.json`).
+   */
+  public async uploadPluginBundle(
     ctx: Context,
-    repo: string,
+    request: UploadPluginBundleRequest,
     args?: EdgeHttpCallArgs,
-  ): Promise<GetPluginVersionsResponseBody> {
-    return this._call(ctx, new URL(`/registry/plugins/${encodeURIComponent(repo)}/versions`, this.baseUrl), {
+  ): Promise<{ moduleUrl: string }> {
+    return this._call(ctx, new URL('/registry/upload', this.baseUrl), {
+      body: request,
+      method: 'POST',
+      auth: true,
       ...args,
-      method: 'GET',
     });
   }
 

package/src/edge-identity.ts

@@ -8,7 +8,11 @@ import { type Presentation } from '@dxos/protocols/proto/dxos/halo/credentials';
 
 export interface EdgeIdentity {
   peerKey: string;
-  identityKey: string;
+  /**
+   * Identity DID (`did:halo:…`) — the public identity segment of the edge WebSocket path.
+   * The router keys connections by the DID.
+   */
+  identityDid: string;
   /**
    * Returns credential presentation issued by the identity key.
    * Presentation must have the provided challenge.

package/src/edge-ws-connection.ts

@@ -60,7 +60,7 @@ export class EdgeWsConnection extends Resource {
   public get info() {
     return {
       open: this.isOpen,
-      identity: this._identity.identityKey,
+      identity: this._identity.identityDid,
       device: this._identity.peerKey,
     };
   }

package/src/edge-ws-muxer.test.ts

@@ -35,7 +35,7 @@ describe('WebSocketMuxerTest', () => {
 
 const textMessage = (message: string, source?: EdgeIdentity) =>
   protocol.createMessage(TextMessageSchema, {
-    source: source && { peerKey: source.peerKey, identityKey: source.identityKey },
+    source: source && { peerKey: source.peerKey, identityDid: source.identityDid },
     serviceId: 'test-service',
     payload: { message },
   });

package/src/hub-http-client.ts

@@ -6,6 +6,7 @@ import { type Context } from '@dxos/context';
 import {
   type CheckEmailExistsResponse,
   type GetAccountResponse,
+  type GetProfileUsageResponse,
   type IssueInvitationResponse,
   type ListAccountInvitationsResponse,
   type LoginRequest,
@@ -17,6 +18,7 @@ import {
   type ResendVerificationEmailResponse,
   type ValidateInvitationCodeResponse,
 } from '@dxos/protocols';
+import { createUrl } from '@dxos/util';
 
 import { BaseHttpClient, type BaseHttpClientOptions, type EdgeHttpCallArgs } from './base-http-client';
 
@@ -115,4 +117,22 @@ export class HubHttpClient extends BaseHttpClient {
   ): Promise<ResendVerificationEmailResponse> {
     return this._call(ctx, new URL('/account/email/resend-verification', this.baseUrl), { ...args, method: 'POST' });
   }
+
+  /**
+   * Rolling-window usage and effective limits for the authenticated identity.
+   * Served from the per-user metering DO; optional `windowSeconds` defaults to the largest limit window.
+   */
+  public async getProfileUsage(
+    ctx: Context,
+    query?: { windowSeconds?: number },
+    args?: EdgeHttpCallArgs,
+  ): Promise<GetProfileUsageResponse> {
+    return this._call(
+      ctx,
+      createUrl(new URL('/api/metering/profile/usage', this.baseUrl), {
+        windowSeconds: query?.windowSeconds,
+      }),
+      { ...args, method: 'GET' },
+    );
+  }
 }

package/src/service/Image.ts

@@ -0,0 +1,61 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+// Image service helpers built on the generic {@link EdgeServiceClient}. The
+// worker exposes two contract-identical routes (`/upload` and `/thumbnail`,
+// both returning `{ id, url }`); we mirror them so callers stay on whichever
+// route they already use.
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { type EdgeServiceClient, type EdgeServiceError } from './edge-service';
+
+/**
+ * Default Composer image-service base URL — the Cloudflare Worker used in
+ * production. Override per-environment via the client's `baseUrl`.
+ */
+// TODO(burdon): Get from config.
+export const DEFAULT_IMAGE_SERVICE_URL = 'https://image-service-main.dxos.workers.dev';
+
+/** Hosted image returned by the service: a CDN `url` and its storage `id`. */
+export const Result = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  url: Schema.String,
+});
+export type Result = typeof Result.Type;
+
+export type UploadOptions = {
+  /** Multipart field name. */
+  field?: string;
+  /** Upload filename. */
+  filename?: string;
+};
+
+/** Store an image and return its hosted CDN URL (POST `/upload`). */
+export const upload = (
+  client: EdgeServiceClient,
+  blob: Blob,
+  opts?: UploadOptions,
+): Effect.Effect<Result, EdgeServiceError> => uploadToPath(client, blob, '/upload', opts);
+
+/** Store an image and create a thumbnail, returning its hosted CDN URL (POST `/thumbnail`). */
+export const thumbnail = (
+  client: EdgeServiceClient,
+  blob: Blob,
+  opts?: UploadOptions,
+): Effect.Effect<Result, EdgeServiceError> => uploadToPath(client, blob, '/thumbnail', opts);
+
+const uploadToPath = (
+  client: EdgeServiceClient,
+  blob: Blob,
+  path: string,
+  opts?: UploadOptions,
+): Effect.Effect<Result, EdgeServiceError> => {
+  const form = new FormData();
+  form.append(opts?.field ?? 'file', blob, opts?.filename ?? 'image');
+  return client.postForm(path, form, Result);
+};