@abassey/aid 0.1.0

package/dist/chunk-IJLTRQF4.cjs

@@ -0,0 +1,276 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/client/errors.ts
+var AidClientError = class _AidClientError extends Error {
+  
+  
+  constructor(code, message, status) {
+    super(message);
+    this.name = "AidClientError";
+    this.code = code;
+    this.status = status;
+  }
+  static fromResponse(body, status) {
+    const err = _optionalChain([body, 'optionalAccess', _ => _.error]);
+    if (err && typeof err.code === "string" && typeof err.message === "string") {
+      return new _AidClientError(err.code, err.message, status);
+    }
+    return new _AidClientError("unknown", `Request failed with status ${status}`, status);
+  }
+};
+
+// src/client/sse.ts
+async function* parseSSE(response) {
+  const body = response.body;
+  if (!body) {
+    throw new AidClientError("network", "Response body is null", 0);
+  }
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split("\n\n");
+      buffer = parts.pop();
+      for (const part of parts) {
+        if (!part.trim()) continue;
+        const lines = part.split("\n");
+        let data = "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            data += line.slice(6);
+          }
+        }
+        if (data) {
+          yield JSON.parse(data);
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const lines = buffer.split("\n");
+      let data = "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          data += line.slice(6);
+        }
+      }
+      if (data) {
+        yield JSON.parse(data);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/client/client.ts
+var AidClient = class {
+  
+  
+  
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.headers = _nullishCoalesce(config.headers, () => ( {}));
+    this.signal = config.signal;
+  }
+  async request(method, path, body, signal) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: _nullishCoalesce(signal, () => ( this.signal))
+    });
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({}));
+      throw AidClientError.fromResponse(errorBody, res.status);
+    }
+    return await res.json();
+  }
+  async requestSSE(path, body, signal) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: JSON.stringify(body),
+      signal: _nullishCoalesce(signal, () => ( this.signal))
+    });
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({}));
+      throw AidClientError.fromResponse(errorBody, res.status);
+    }
+    return res;
+  }
+  // === Core AI ===
+  async ai(prompt, options) {
+    const { signal, ...rest } = _nullishCoalesce(options, () => ( {}));
+    return this.request("POST", "/ai", { prompt, ...rest }, signal);
+  }
+  async *stream(prompt, options) {
+    const { signal, ...rest } = _nullishCoalesce(options, () => ( {}));
+    const res = await this.requestSSE("/ai/stream", { prompt, ...rest }, signal);
+    let accumulated = "";
+    for await (const raw of parseSSE(res)) {
+      const type = raw.type;
+      if (type === "text") {
+        const delta = _nullishCoalesce(raw.text, () => ( ""));
+        accumulated += delta;
+        yield {
+          type: "text",
+          text: accumulated,
+          delta
+        };
+      } else if (type === "done") {
+        yield {
+          type: "done",
+          text: _nullishCoalesce(raw.text, () => ( accumulated)),
+          delta: "",
+          model: raw.model,
+          tokens: raw.tokens,
+          cost: raw.cost,
+          latencyMs: raw.latencyMs
+        };
+      } else if (type === "error") {
+        yield {
+          type: "error",
+          text: accumulated,
+          delta: "",
+          code: raw.code,
+          message: raw.message
+        };
+      }
+    }
+  }
+  // === Agents ===
+  async agent(name, task, options) {
+    return this.request(
+      "POST",
+      `/agents/${encodeURIComponent(name)}`,
+      { task },
+      _optionalChain([options, 'optionalAccess', _2 => _2.signal])
+    );
+  }
+  // Design note: The spec mentions AgentEventStream with `.on()` callbacks.
+  // We use a plain AsyncGenerator instead — simpler, composable, and the React
+  // hook (useAgent) handles the callback-style consumption pattern.
+  async *agentStream(name, task, options) {
+    const res = await this.requestSSE(
+      `/agents/${encodeURIComponent(name)}/stream`,
+      { task },
+      _optionalChain([options, 'optionalAccess', _3 => _3.signal])
+    );
+    yield* parseSSE(res);
+  }
+  // === Chat ===
+  chat(options) {
+    return new ChatClient(this, options);
+  }
+  // Internal: used by ChatClient
+  /** @internal */
+  async _chatCreate(options) {
+    return this.request("POST", "/chat", _nullishCoalesce(options, () => ( {})));
+  }
+  /** @internal */
+  async _chatSend(sessionId, message) {
+    return this.request("POST", `/chat/${encodeURIComponent(sessionId)}`, { message });
+  }
+  /** @internal */
+  async *_chatStream(sessionId, message, signal) {
+    const res = await this.requestSSE(
+      `/chat/${encodeURIComponent(sessionId)}/stream`,
+      { message },
+      signal
+    );
+    let accumulated = "";
+    for await (const raw of parseSSE(res)) {
+      const type = raw.type;
+      if (type === "text") {
+        const delta = _nullishCoalesce(raw.text, () => ( ""));
+        accumulated += delta;
+        yield { type: "text", text: accumulated, delta };
+      } else if (type === "done") {
+        yield {
+          type: "done",
+          text: _nullishCoalesce(raw.text, () => ( accumulated)),
+          delta: "",
+          model: raw.model,
+          tokens: raw.tokens,
+          cost: raw.cost,
+          latencyMs: raw.latencyMs
+        };
+      } else if (type === "error") {
+        yield { type: "error", text: accumulated, delta: "", code: raw.code, message: raw.message };
+      }
+    }
+  }
+  /** @internal */
+  async _chatHistory(sessionId) {
+    return this.request("GET", `/chat/${encodeURIComponent(sessionId)}`);
+  }
+  /** @internal */
+  async _chatDelete(sessionId) {
+    await this.request("DELETE", `/chat/${encodeURIComponent(sessionId)}`);
+  }
+  // === Utility ===
+  async health() {
+    return this.request("GET", "/health");
+  }
+  async models() {
+    const result = await this.request(
+      "GET",
+      "/models"
+    );
+    return result.models;
+  }
+};
+var ChatClient = (_class = class {
+  __init() {this._sessionId = null}
+  
+  
+  constructor(client, options) {;_class.prototype.__init.call(this);
+    this.client = client;
+    this.chatOptions = options;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  async ensureSession() {
+    if (!this._sessionId) {
+      const session = await this.client._chatCreate(this.chatOptions);
+      this._sessionId = session.sessionId;
+    }
+    return this._sessionId;
+  }
+  async send(message) {
+    const sessionId = await this.ensureSession();
+    return this.client._chatSend(sessionId, message);
+  }
+  async *stream(message, signal) {
+    const sessionId = await this.ensureSession();
+    yield* this.client._chatStream(sessionId, message, signal);
+  }
+  async history() {
+    if (!this._sessionId) {
+      return { sessionId: "", messages: [], createdAt: 0, lastActiveAt: 0 };
+    }
+    return this.client._chatHistory(this._sessionId);
+  }
+  async destroy() {
+    if (this._sessionId) {
+      await this.client._chatDelete(this._sessionId);
+      this._sessionId = null;
+    }
+  }
+}, _class);
+
+
+
+
+
+
+exports.AidClientError = AidClientError; exports.parseSSE = parseSSE; exports.AidClient = AidClient; exports.ChatClient = ChatClient;

package/dist/chunk-JPD7UBAZ.js

@@ -0,0 +1,58 @@
+// src/observability/trace-store.ts
+var InMemoryTraceStore = class {
+  spans = /* @__PURE__ */ new Map();
+  order = [];
+  maxSpans;
+  constructor(options) {
+    this.maxSpans = options?.maxSpans ?? 1e4;
+  }
+  add(span) {
+    this.spans.set(span.id, span);
+    this.order.push(span.id);
+    while (this.order.length > this.maxSpans) {
+      const oldestId = this.order.shift();
+      this.spans.delete(oldestId);
+    }
+  }
+  get(id) {
+    return this.spans.get(id);
+  }
+  list(filter) {
+    let spans = Array.from(this.spans.values());
+    if (!filter) return spans;
+    if (filter.name !== void 0) {
+      spans = spans.filter((s) => s.name === filter.name);
+    }
+    if (filter.model !== void 0) {
+      spans = spans.filter((s) => s.model === filter.model);
+    }
+    if (filter.status !== void 0) {
+      spans = spans.filter((s) => s.status === filter.status);
+    }
+    if (filter.from !== void 0) {
+      spans = spans.filter((s) => s.startTime >= filter.from);
+    }
+    if (filter.to !== void 0) {
+      spans = spans.filter((s) => s.startTime < filter.to);
+    }
+    if (filter.parentId !== void 0) {
+      spans = spans.filter((s) => s.parentId === filter.parentId);
+    }
+    return spans;
+  }
+  clear() {
+    this.spans.clear();
+    this.order = [];
+  }
+};
+
+// src/observability/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var traceContext = new AsyncLocalStorage();
+var globalTraceStore = new InMemoryTraceStore();
+
+export {
+  InMemoryTraceStore,
+  traceContext,
+  globalTraceStore
+};

package/dist/chunk-M4RQALTT.js

@@ -0,0 +1,276 @@
+// src/client/errors.ts
+var AidClientError = class _AidClientError extends Error {
+  code;
+  status;
+  constructor(code, message, status) {
+    super(message);
+    this.name = "AidClientError";
+    this.code = code;
+    this.status = status;
+  }
+  static fromResponse(body, status) {
+    const err = body?.error;
+    if (err && typeof err.code === "string" && typeof err.message === "string") {
+      return new _AidClientError(err.code, err.message, status);
+    }
+    return new _AidClientError("unknown", `Request failed with status ${status}`, status);
+  }
+};
+
+// src/client/sse.ts
+async function* parseSSE(response) {
+  const body = response.body;
+  if (!body) {
+    throw new AidClientError("network", "Response body is null", 0);
+  }
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split("\n\n");
+      buffer = parts.pop();
+      for (const part of parts) {
+        if (!part.trim()) continue;
+        const lines = part.split("\n");
+        let data = "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            data += line.slice(6);
+          }
+        }
+        if (data) {
+          yield JSON.parse(data);
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const lines = buffer.split("\n");
+      let data = "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          data += line.slice(6);
+        }
+      }
+      if (data) {
+        yield JSON.parse(data);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/client/client.ts
+var AidClient = class {
+  baseUrl;
+  headers;
+  signal;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.headers = config.headers ?? {};
+    this.signal = config.signal;
+  }
+  async request(method, path, body, signal) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: signal ?? this.signal
+    });
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({}));
+      throw AidClientError.fromResponse(errorBody, res.status);
+    }
+    return await res.json();
+  }
+  async requestSSE(path, body, signal) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: JSON.stringify(body),
+      signal: signal ?? this.signal
+    });
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({}));
+      throw AidClientError.fromResponse(errorBody, res.status);
+    }
+    return res;
+  }
+  // === Core AI ===
+  async ai(prompt, options) {
+    const { signal, ...rest } = options ?? {};
+    return this.request("POST", "/ai", { prompt, ...rest }, signal);
+  }
+  async *stream(prompt, options) {
+    const { signal, ...rest } = options ?? {};
+    const res = await this.requestSSE("/ai/stream", { prompt, ...rest }, signal);
+    let accumulated = "";
+    for await (const raw of parseSSE(res)) {
+      const type = raw.type;
+      if (type === "text") {
+        const delta = raw.text ?? "";
+        accumulated += delta;
+        yield {
+          type: "text",
+          text: accumulated,
+          delta
+        };
+      } else if (type === "done") {
+        yield {
+          type: "done",
+          text: raw.text ?? accumulated,
+          delta: "",
+          model: raw.model,
+          tokens: raw.tokens,
+          cost: raw.cost,
+          latencyMs: raw.latencyMs
+        };
+      } else if (type === "error") {
+        yield {
+          type: "error",
+          text: accumulated,
+          delta: "",
+          code: raw.code,
+          message: raw.message
+        };
+      }
+    }
+  }
+  // === Agents ===
+  async agent(name, task, options) {
+    return this.request(
+      "POST",
+      `/agents/${encodeURIComponent(name)}`,
+      { task },
+      options?.signal
+    );
+  }
+  // Design note: The spec mentions AgentEventStream with `.on()` callbacks.
+  // We use a plain AsyncGenerator instead — simpler, composable, and the React
+  // hook (useAgent) handles the callback-style consumption pattern.
+  async *agentStream(name, task, options) {
+    const res = await this.requestSSE(
+      `/agents/${encodeURIComponent(name)}/stream`,
+      { task },
+      options?.signal
+    );
+    yield* parseSSE(res);
+  }
+  // === Chat ===
+  chat(options) {
+    return new ChatClient(this, options);
+  }
+  // Internal: used by ChatClient
+  /** @internal */
+  async _chatCreate(options) {
+    return this.request("POST", "/chat", options ?? {});
+  }
+  /** @internal */
+  async _chatSend(sessionId, message) {
+    return this.request("POST", `/chat/${encodeURIComponent(sessionId)}`, { message });
+  }
+  /** @internal */
+  async *_chatStream(sessionId, message, signal) {
+    const res = await this.requestSSE(
+      `/chat/${encodeURIComponent(sessionId)}/stream`,
+      { message },
+      signal
+    );
+    let accumulated = "";
+    for await (const raw of parseSSE(res)) {
+      const type = raw.type;
+      if (type === "text") {
+        const delta = raw.text ?? "";
+        accumulated += delta;
+        yield { type: "text", text: accumulated, delta };
+      } else if (type === "done") {
+        yield {
+          type: "done",
+          text: raw.text ?? accumulated,
+          delta: "",
+          model: raw.model,
+          tokens: raw.tokens,
+          cost: raw.cost,
+          latencyMs: raw.latencyMs
+        };
+      } else if (type === "error") {
+        yield { type: "error", text: accumulated, delta: "", code: raw.code, message: raw.message };
+      }
+    }
+  }
+  /** @internal */
+  async _chatHistory(sessionId) {
+    return this.request("GET", `/chat/${encodeURIComponent(sessionId)}`);
+  }
+  /** @internal */
+  async _chatDelete(sessionId) {
+    await this.request("DELETE", `/chat/${encodeURIComponent(sessionId)}`);
+  }
+  // === Utility ===
+  async health() {
+    return this.request("GET", "/health");
+  }
+  async models() {
+    const result = await this.request(
+      "GET",
+      "/models"
+    );
+    return result.models;
+  }
+};
+var ChatClient = class {
+  _sessionId = null;
+  chatOptions;
+  client;
+  constructor(client, options) {
+    this.client = client;
+    this.chatOptions = options;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  async ensureSession() {
+    if (!this._sessionId) {
+      const session = await this.client._chatCreate(this.chatOptions);
+      this._sessionId = session.sessionId;
+    }
+    return this._sessionId;
+  }
+  async send(message) {
+    const sessionId = await this.ensureSession();
+    return this.client._chatSend(sessionId, message);
+  }
+  async *stream(message, signal) {
+    const sessionId = await this.ensureSession();
+    yield* this.client._chatStream(sessionId, message, signal);
+  }
+  async history() {
+    if (!this._sessionId) {
+      return { sessionId: "", messages: [], createdAt: 0, lastActiveAt: 0 };
+    }
+    return this.client._chatHistory(this._sessionId);
+  }
+  async destroy() {
+    if (this._sessionId) {
+      await this.client._chatDelete(this._sessionId);
+      this._sessionId = null;
+    }
+  }
+};
+
+export {
+  AidClientError,
+  parseSSE,
+  AidClient,
+  ChatClient
+};

package/dist/chunk-NB65IHJE.cjs

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/observability/trace-store.ts
+var InMemoryTraceStore = (_class = class {
+  __init() {this.spans = /* @__PURE__ */ new Map()}
+  __init2() {this.order = []}
+  
+  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.maxSpans = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.maxSpans]), () => ( 1e4));
+  }
+  add(span) {
+    this.spans.set(span.id, span);
+    this.order.push(span.id);
+    while (this.order.length > this.maxSpans) {
+      const oldestId = this.order.shift();
+      this.spans.delete(oldestId);
+    }
+  }
+  get(id) {
+    return this.spans.get(id);
+  }
+  list(filter) {
+    let spans = Array.from(this.spans.values());
+    if (!filter) return spans;
+    if (filter.name !== void 0) {
+      spans = spans.filter((s) => s.name === filter.name);
+    }
+    if (filter.model !== void 0) {
+      spans = spans.filter((s) => s.model === filter.model);
+    }
+    if (filter.status !== void 0) {
+      spans = spans.filter((s) => s.status === filter.status);
+    }
+    if (filter.from !== void 0) {
+      spans = spans.filter((s) => s.startTime >= filter.from);
+    }
+    if (filter.to !== void 0) {
+      spans = spans.filter((s) => s.startTime < filter.to);
+    }
+    if (filter.parentId !== void 0) {
+      spans = spans.filter((s) => s.parentId === filter.parentId);
+    }
+    return spans;
+  }
+  clear() {
+    this.spans.clear();
+    this.order = [];
+  }
+}, _class);
+
+// src/observability/context.ts
+var _async_hooks = require('async_hooks');
+var traceContext = new (0, _async_hooks.AsyncLocalStorage)();
+var globalTraceStore = new InMemoryTraceStore();
+
+
+
+
+
+exports.InMemoryTraceStore = InMemoryTraceStore; exports.traceContext = traceContext; exports.globalTraceStore = globalTraceStore;