@meso.ai/client 0.1.0

package/dist/__tests__/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/confirm.d.ts

@@ -0,0 +1,21 @@
+export interface ToolConfirmRequest {
+    tool_call_id: string;
+    approved: boolean;
+    session_id?: string;
+}
+export interface ToolConfirmChannel {
+    confirm(request: ToolConfirmRequest): Promise<void>;
+}
+export interface FetchConfirmChannelOptions {
+    /** Endpoint that receives tool approval decisions. Default /api/tools/confirm */
+    url?: string;
+    headers?: Record<string, string>;
+}
+/** POST tool confirm decisions to a backend endpoint. */
+export declare class FetchConfirmChannel implements ToolConfirmChannel {
+    private url;
+    private headers;
+    constructor(options?: FetchConfirmChannelOptions);
+    confirm(request: ToolConfirmRequest): Promise<void>;
+}
+export declare function confirmTool(channel: ToolConfirmChannel, toolCallId: string, approved: boolean, sessionId?: string): Promise<void>;

package/dist/index.cjs

@@ -0,0 +1,3 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("@meso.ai/types");class p{constructor(e){this.data={...(e==null?void 0:e.initial)??{}}}async getMessages(e){return[...this.data[e]??[]]}async saveMessages(e,s){this.data[e]=[...s]}}class M{async stream(e,s){const d=e.method??(e.body?"POST":"GET"),o=await fetch(e.url,{method:d,headers:{...d==="POST"?{"Content-Type":"application/json"}:{},...e.headers},body:e.body?JSON.stringify(e.body):void 0,signal:e.signal});if(!o.ok)throw new Error(`HTTP ${o.status}`);const y=o.body.getReader(),f=new TextDecoder;let t="",n={...l.createInitialStreamState(),status:"streaming"};for(;;){const{done:c,value:r}=await y.read();if(c)break;t+=f.decode(r,{stream:!0});const u=t.split(`
+`);t=u.pop()??"";for(const h of u){const i=l.parseSSELine(h);if(i&&(n=l.applyEvent(n,i),s(i,n),i.type==="done"||i.type==="error"))return n}}return n}}class b{constructor(e){this.url=(e==null?void 0:e.url)??"/api/tools/confirm",this.headers=(e==null?void 0:e.headers)??{}}async confirm(e){const s=await fetch(this.url,{method:"POST",headers:{"Content-Type":"application/json",...this.headers},body:JSON.stringify(e)});if(!s.ok)throw new Error(`Tool confirm failed: HTTP ${s.status}`)}}async function I(a,e,s,d){await a.confirm({tool_call_id:e,approved:s,session_id:d})}let T=0;function S(a){return T+=1,`${a}-${T}`}function O(a){const{sessionId:e,streamUrl:s,transport:d=new M,store:o=new p,confirmChannel:y=new b,headers:f,onStreamState:t}=a;let n=[],c=l.createInitialStreamState(),r=null;const u=async()=>{await o.saveMessages(e,n)};return{sessionId:e,get messages(){return n},get streaming(){return c},async load(){n=await o.getMessages(e)},resetStream(){r==null||r.abort(),c=l.createInitialStreamState(),t==null||t(c)},async sendMessage(i){r==null||r.abort(),r=new AbortController;const g={id:S("user"),role:"user",content:i,timestamp:new Date().toISOString()};n=[...n,g],await u(),c={...l.createInitialStreamState(),status:"streaming"},t==null||t(c);const m=await d.stream({url:s,method:"POST",headers:f,body:{session_id:e,message:i},signal:r.signal},(E,w)=>{c=w,t==null||t(w)});c=m,t==null||t(m);const v={id:S("assistant"),role:"assistant",content:m.textContent,streamState:m,timestamp:new Date().toISOString()};n=[...n,v],await u()},async confirmToolCall(i,g){await I(y,i,g,e)}}}function C(a){return a.split(`
+`).reduce((s,d)=>{const o=l.parseSSELine(d);return o?l.applyEvent(s,o):s},{...l.createInitialStreamState(),status:"streaming"})}exports.FetchConfirmChannel=b;exports.FetchMesoTransport=M;exports.InMemorySessionStore=p;exports.confirmTool=I;exports.createMesoSession=O;exports.replayTurn=C;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { createMesoSession } from './session';
+export type { CreateMesoSessionOptions, MesoSession } from './session';
+export { InMemorySessionStore } from './store';
+export type { MesoMessage, MesoSessionStore } from './store';
+export { FetchMesoTransport } from './transport';
+export type { MesoTransport, MesoTransportRequest } from './transport';
+export { FetchConfirmChannel, confirmTool } from './confirm';
+export type { ToolConfirmChannel, ToolConfirmRequest } from './confirm';
+export { replayTurn } from './replay';

package/dist/index.js

@@ -0,0 +1,148 @@
+import { createInitialStreamState as u, parseSSELine as M, applyEvent as b } from "@meso.ai/types";
+class O {
+  constructor(e) {
+    this.data = { ...(e == null ? void 0 : e.initial) ?? {} };
+  }
+  async getMessages(e) {
+    return [...this.data[e] ?? []];
+  }
+  async saveMessages(e, t) {
+    this.data[e] = [...t];
+  }
+}
+class C {
+  async stream(e, t) {
+    const l = e.method ?? (e.body ? "POST" : "GET"), o = await fetch(e.url, {
+      method: l,
+      headers: {
+        ...l === "POST" ? { "Content-Type": "application/json" } : {},
+        ...e.headers
+      },
+      body: e.body ? JSON.stringify(e.body) : void 0,
+      signal: e.signal
+    });
+    if (!o.ok) throw new Error(`HTTP ${o.status}`);
+    const g = o.body.getReader(), h = new TextDecoder();
+    let s = "", n = { ...u(), status: "streaming" };
+    for (; ; ) {
+      const { done: c, value: r } = await g.read();
+      if (c) break;
+      s += h.decode(r, { stream: !0 });
+      const d = s.split(`
+`);
+      s = d.pop() ?? "";
+      for (const y of d) {
+        const i = M(y);
+        if (i && (n = b(n, i), t(i, n), i.type === "done" || i.type === "error"))
+          return n;
+      }
+    }
+    return n;
+  }
+}
+class I {
+  constructor(e) {
+    this.url = (e == null ? void 0 : e.url) ?? "/api/tools/confirm", this.headers = (e == null ? void 0 : e.headers) ?? {};
+  }
+  async confirm(e) {
+    const t = await fetch(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...this.headers },
+      body: JSON.stringify(e)
+    });
+    if (!t.ok) throw new Error(`Tool confirm failed: HTTP ${t.status}`);
+  }
+}
+async function P(a, e, t, l) {
+  await a.confirm({
+    tool_call_id: e,
+    approved: t,
+    session_id: l
+  });
+}
+let T = 0;
+function p(a) {
+  return T += 1, `${a}-${T}`;
+}
+function _(a) {
+  const {
+    sessionId: e,
+    streamUrl: t,
+    transport: l = new C(),
+    store: o = new O(),
+    confirmChannel: g = new I(),
+    headers: h,
+    onStreamState: s
+  } = a;
+  let n = [], c = u(), r = null;
+  const d = async () => {
+    await o.saveMessages(e, n);
+  };
+  return {
+    sessionId: e,
+    get messages() {
+      return n;
+    },
+    get streaming() {
+      return c;
+    },
+    async load() {
+      n = await o.getMessages(e);
+    },
+    resetStream() {
+      r == null || r.abort(), c = u(), s == null || s(c);
+    },
+    async sendMessage(i) {
+      r == null || r.abort(), r = new AbortController();
+      const m = {
+        id: p("user"),
+        role: "user",
+        content: i,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      n = [...n, m], await d(), c = { ...u(), status: "streaming" }, s == null || s(c);
+      const f = await l.stream(
+        {
+          url: t,
+          method: "POST",
+          headers: h,
+          body: { session_id: e, message: i },
+          signal: r.signal
+        },
+        (E, w) => {
+          c = w, s == null || s(w);
+        }
+      );
+      c = f, s == null || s(f);
+      const v = {
+        id: p("assistant"),
+        role: "assistant",
+        content: f.textContent,
+        streamState: f,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      n = [...n, v], await d();
+    },
+    async confirmToolCall(i, m) {
+      await P(g, i, m, e);
+    }
+  };
+}
+function $(a) {
+  return a.split(`
+`).reduce(
+    (t, l) => {
+      const o = M(l);
+      return o ? b(t, o) : t;
+    },
+    { ...u(), status: "streaming" }
+  );
+}
+export {
+  I as FetchConfirmChannel,
+  C as FetchMesoTransport,
+  O as InMemorySessionStore,
+  P as confirmTool,
+  _ as createMesoSession,
+  $ as replayTurn
+};

package/dist/replay.d.ts

@@ -0,0 +1,3 @@
+import { type StreamState } from '@meso.ai/types';
+/** Replay a fixture string (one SSE line per row) into a final StreamState. */
+export declare function replayTurn(fixture: string): StreamState;

package/dist/session.d.ts

@@ -0,0 +1,23 @@
+import { type StreamState } from '@meso.ai/types';
+import type { MesoMessage, MesoSessionStore } from './store';
+import { type MesoTransport } from './transport';
+import { type ToolConfirmChannel } from './confirm';
+export interface CreateMesoSessionOptions {
+    sessionId: string;
+    streamUrl: string;
+    transport?: MesoTransport;
+    store?: MesoSessionStore;
+    confirmChannel?: ToolConfirmChannel;
+    headers?: Record<string, string>;
+    onStreamState?: (state: StreamState) => void;
+}
+export interface MesoSession {
+    sessionId: string;
+    messages: MesoMessage[];
+    streaming: StreamState;
+    sendMessage(text: string): Promise<void>;
+    confirmToolCall(toolCallId: string, approved: boolean): Promise<void>;
+    load(): Promise<void>;
+    resetStream(): void;
+}
+export declare function createMesoSession(options: CreateMesoSessionOptions): MesoSession;

package/dist/store.d.ts

@@ -0,0 +1,23 @@
+import type { StreamState } from '@meso.ai/types';
+export interface MesoMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    /** Snapshot of StreamState for assistant turns (optional). */
+    streamState?: StreamState;
+    timestamp?: string;
+}
+export interface MesoSessionStore {
+    getMessages(sessionId: string): Promise<MesoMessage[]>;
+    saveMessages(sessionId: string, messages: MesoMessage[]): Promise<void>;
+}
+export interface InMemorySessionStoreOptions {
+    initial?: Record<string, MesoMessage[]>;
+}
+/** Simple in-memory store for demos and tests. */
+export declare class InMemorySessionStore implements MesoSessionStore {
+    private data;
+    constructor(options?: InMemorySessionStoreOptions);
+    getMessages(sessionId: string): Promise<MesoMessage[]>;
+    saveMessages(sessionId: string, messages: MesoMessage[]): Promise<void>;
+}

package/dist/transport.d.ts

@@ -0,0 +1,16 @@
+import { type StreamState, type SSEEvent } from '@meso.ai/types';
+export interface MesoTransportRequest {
+    url: string;
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+export interface MesoTransport {
+    /** Open an SSE stream and invoke onEvent for each parsed event. */
+    stream(request: MesoTransportRequest, onEvent: (event: SSEEvent, state: StreamState) => void): Promise<StreamState>;
+}
+/** Default fetch-based transport for browser and Node 18+. */
+export declare class FetchMesoTransport implements MesoTransport {
+    stream(request: MesoTransportRequest, onEvent: (event: SSEEvent, state: StreamState) => void): Promise<StreamState>;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@meso.ai/client",
+  "version": "0.1.0",
+  "description": "Meso session layer — turn management, transport, tool confirm, replay",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Grant-Huang/Meso.git",
+    "directory": "packages/meso-client"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@meso.ai/types": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vite": "^5.4.11",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^2.1.9"
+  }
+}