@arcote.tech/arc-ai 0.5.1 → 0.5.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-ai",
   "type": "module",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "private": false,
   "description": "AI provider abstraction, completion tracking, and budget management for Arc framework",
   "main": "./src/index.ts",
@@ -10,8 +10,8 @@
     "type-check": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.5.1",
-    "@arcote.tech/arc-auth": "^0.5.1",
+    "@arcote.tech/arc": "^0.5.2",
+    "@arcote.tech/arc-auth": "^0.5.2",
     "typescript": "^5.0.0"
   },
   "devDependencies": {

package/src/aggregates/credit-ledger.ts

@@ -0,0 +1,178 @@
+/// <reference path="../arc.d.ts" />
+import {
+  aggregate,
+  context,
+  id,
+  number,
+  string,
+  type ArcId,
+} from "@arcote.tech/arc";
+import type { Token } from "@arcote.tech/arc-auth";
+
+// ─── ID ──────────────────────────────────────────────────────────
+
+export const createLedgerId = <const Name extends string>(data: {
+  name: Name;
+}) => id(`${data.name}Ledger`);
+
+// ─── Factory ────────────────────────────────────────────────────
+
+export function creditLedger(config: {
+  name: string;
+  scopeId: ArcId<any>;
+  accountId: ArcId<any>;
+  protectBy: Token;
+}) {
+  const { name, scopeId, protectBy } = config;
+  const ledgerId = createLedgerId({ name });
+
+  const Ledger = aggregate(`${name}Ledger`, ledgerId, {
+    scopeId,
+    balance: number(),
+    totalCredited: number(),
+    totalDebited: number(),
+  })
+
+    // ─── credited — top up balance ──────────────────────────────
+    .publicEvent(
+      "credited",
+      {
+        ledgerId,
+        scopeId,
+        amount: number(),
+        reason: string(),
+        metadata: string().optional(),
+      },
+      async (ctx, event) => {
+        const p = event.payload;
+        const existing = await ctx.findOne({ scopeId: p.scopeId });
+
+        if (existing) {
+          await ctx.set(existing._id, {
+            ...existing,
+            balance: (existing.balance ?? 0) + p.amount,
+            totalCredited: (existing.totalCredited ?? 0) + p.amount,
+          });
+        } else {
+          await ctx.set(p.ledgerId, {
+            scopeId: p.scopeId,
+            balance: p.amount,
+            totalCredited: p.amount,
+            totalDebited: 0,
+          });
+        }
+      },
+    )
+
+    // ─── debited — deduct from balance ──────────────────────────
+    .publicEvent(
+      "debited",
+      {
+        ledgerId,
+        scopeId,
+        amount: number(),
+        reason: string(),
+        model: string().optional(),
+        metadata: string().optional(),
+      },
+      async (ctx, event) => {
+        const p = event.payload;
+        const existing = await ctx.findOne({ scopeId: p.scopeId });
+
+        if (existing) {
+          await ctx.set(existing._id, {
+            ...existing,
+            balance: (existing.balance ?? 0) - p.amount,
+            totalDebited: (existing.totalDebited ?? 0) + p.amount,
+          });
+        } else {
+          await ctx.set(p.ledgerId, {
+            scopeId: p.scopeId,
+            balance: -p.amount,
+            totalCredited: 0,
+            totalDebited: p.amount,
+          });
+        }
+      },
+    )
+
+    // ─── topUp — add credits ────────────────────────────────────
+    .mutateMethod(
+      "topUp",
+      (fn) => fn.withParams({
+        scopeId,
+        amount: number(),
+        reason: string(),
+        metadata: string().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          const entryId = ledgerId.generate();
+          await ctx.credited.emit({
+            ledgerId: entryId,
+            scopeId: params.scopeId,
+            amount: params.amount,
+            reason: params.reason,
+            metadata: params.metadata,
+          });
+          return { ok: true };
+        }),
+      ),
+    )
+
+    // ─── deduct — remove credits ────────────────────────────────
+    .mutateMethod(
+      "deduct",
+      (fn) => fn.withParams({
+        scopeId,
+        amount: number(),
+        reason: string(),
+        model: string().optional(),
+        metadata: string().optional(),
+      }).handle(
+        ONLY_SERVER &&
+        (async (ctx, params) => {
+          const entryId = ledgerId.generate();
+          await ctx.debited.emit({
+            ledgerId: entryId,
+            scopeId: params.scopeId,
+            amount: params.amount,
+            reason: params.reason,
+            model: params.model,
+            metadata: params.metadata,
+          });
+          return { ok: true };
+        }),
+      ),
+    )
+
+    // ─── checkBalance — query current balance ───────────────────
+    .clientQuery(
+      "checkBalance",
+      (fn) => fn
+        .withParams({ scopeId: string() })
+        .handle(async (ctx, params) => {
+          const entry = await ctx.$query.findOne({ scopeId: params.scopeId });
+          const balance = entry?.balance ?? 0;
+          return {
+            balance,
+            canUse: balance > 0,
+            totalCredited: entry?.totalCredited ?? 0,
+            totalDebited: entry?.totalDebited ?? 0,
+          };
+        }),
+    )
+
+    .protectBy(protectBy, (p: any) => ({ scopeId: p.workspaceId ?? p.accountId }));
+
+  const elements = [Ledger];
+
+  return {
+    context: context(elements),
+    elements,
+    ledgerId,
+    Ledger,
+  };
+}
+
+export type CreditLedgerConfig = ReturnType<typeof creditLedger>;

package/src/ai-builder.ts

@@ -1,54 +1,37 @@
 import { context, type ArcContextElement } from "@arcote.tech/arc";
 import type { AccountId, Token } from "@arcote.tech/arc-auth";
-import {
-  createCompletionId,
-  createCompletionAggregate,
-} from "./aggregates/completion";
-import {
-  createBudgetId,
-  createBudgetAggregate,
-} from "./aggregates/budget";
-import type { LLMProvider, PricingConfig } from "./types";
+import type { CreditLedgerConfig } from "./aggregates/credit-ledger";
+import type { BillingStrategy } from "./billing/types";
+import { wrapProviderWithBilling } from "./billing/wrap-provider";
+import type { LLMProvider } from "./types";
 
 export function ai(config: {
   name: string;
   accountId: AccountId;
   userToken: Token;
   providers: LLMProvider[];
-  pricing?: Record<string, PricingConfig>;
+  billing?: {
+    ledger: CreditLedgerConfig;
+    strategy: BillingStrategy;
+  };
 }) {
-  const completionId = createCompletionId({ name: config.name });
-  const budgetId = createBudgetId({ name: config.name });
-
-  const Completion = createCompletionAggregate({
-    name: config.name,
-    completionId,
-    accountId: config.accountId,
-    userToken: config.userToken,
-    providers: config.providers,
-    pricing: config.pricing,
-  });
-
-  const Budget = createBudgetAggregate({
-    name: config.name,
-    budgetId,
-    accountId: config.accountId,
-    userToken: config.userToken,
-    CompletionAggregate: Completion,
-  });
+  const elements: ArcContextElement<any>[] = [];
 
-  const elements: ArcContextElement<any>[] = [Completion, Budget];
+  if (config.billing) {
+    elements.push(...config.billing.ledger.elements);
+  }
 
   return {
     context: context(elements),
     elements,
-    completionId,
-    budgetId,
-    Completion,
-    Budget,
     providers: config.providers,
-    resolveProvider: (model: string) =>
-      config.providers.find((p) => p.models.includes(model)),
+    billing: config.billing,
+    resolveProvider: (model: string, scopeId?: string): LLMProvider | undefined => {
+      const provider = config.providers.find((p) => p.models.includes(model));
+      if (!provider) return undefined;
+      if (!config.billing || !scopeId) return provider;
+      return wrapProviderWithBilling(provider, config.billing, scopeId);
+    },
   };
 }
 

package/src/billing/index.ts

@@ -0,0 +1,5 @@
+export type { BillingStrategy, AdapterPricing } from "./types";
+export { fixedMarkupStrategy } from "./strategies/fixed-markup";
+export { flatRateStrategy } from "./strategies/flat-rate";
+export { tokenPassStrategy } from "./strategies/token-pass";
+export { wrapProviderWithBilling } from "./wrap-provider";

package/src/billing/strategies/fixed-markup.ts

@@ -0,0 +1,32 @@
+import type { BillingStrategy, AdapterPricing } from "../types";
+import type { TokenUsage } from "../../types";
+
+export function fixedMarkupStrategy(config: {
+  multiplier: number;
+}): BillingStrategy {
+  const { multiplier } = config;
+
+  return {
+    name: "fixedMarkup",
+
+    calculateCost({ usage, adapterPricing }) {
+      if (!adapterPricing) return 0;
+
+      const inputCost = (usage.inputTokens / 1_000_000) * adapterPricing.inputPer1M;
+      const outputCost = (usage.outputTokens / 1_000_000) * adapterPricing.outputPer1M;
+      const cachedCost = adapterPricing.cachedInputPer1M
+        ? (usage.cachedTokens / 1_000_000) * adapterPricing.cachedInputPer1M
+        : 0;
+      const reasoningCost = adapterPricing.reasoningPer1M
+        ? (usage.reasoningTokens / 1_000_000) * adapterPricing.reasoningPer1M
+        : 0;
+
+      const baseCost = inputCost + outputCost + cachedCost + reasoningCost;
+      return Math.round(baseCost * multiplier * 100) / 100;
+    },
+
+    canExecute(balance) {
+      return balance > 0;
+    },
+  };
+}

package/src/billing/strategies/flat-rate.ts

@@ -0,0 +1,19 @@
+import type { BillingStrategy } from "../types";
+
+export function flatRateStrategy(config: {
+  creditsPerRequest: number;
+}): BillingStrategy {
+  const { creditsPerRequest } = config;
+
+  return {
+    name: "flatRate",
+
+    calculateCost() {
+      return creditsPerRequest;
+    },
+
+    canExecute(balance) {
+      return balance > 0;
+    },
+  };
+}

package/src/billing/strategies/index.ts

@@ -0,0 +1,3 @@
+export { fixedMarkupStrategy } from "./fixed-markup";
+export { flatRateStrategy } from "./flat-rate";
+export { tokenPassStrategy } from "./token-pass";

package/src/billing/strategies/token-pass.ts

@@ -0,0 +1,15 @@
+import type { BillingStrategy } from "../types";
+
+export function tokenPassStrategy(): BillingStrategy {
+  return {
+    name: "tokenPass",
+
+    calculateCost({ usage }) {
+      return usage.totalTokens;
+    },
+
+    canExecute(balance) {
+      return balance > 0;
+    },
+  };
+}

package/src/billing/types.ts

@@ -0,0 +1,24 @@
+import type { TokenUsage } from "../types";
+
+// ─── Adapter Pricing ────────────────────────────────────────────
+
+export interface AdapterPricing {
+  inputPer1M: number;
+  outputPer1M: number;
+  cachedInputPer1M?: number;
+  reasoningPer1M?: number;
+}
+
+// ─── Billing Strategy ───────────────────────────────────────────
+
+export interface BillingStrategy {
+  readonly name: string;
+
+  calculateCost(params: {
+    model: string;
+    usage: TokenUsage;
+    adapterPricing?: AdapterPricing;
+  }): number;
+
+  canExecute(balance: number): boolean;
+}

package/src/billing/wrap-provider.ts

@@ -0,0 +1,52 @@
+import type { LLMProvider, CompletionRequest, CompletionResult, StreamChunk } from "../types";
+import type { CreditLedgerConfig } from "../aggregates/credit-ledger";
+import type { BillingStrategy } from "./types";
+
+export function wrapProviderWithBilling(
+  provider: LLMProvider,
+  billing: { ledger: CreditLedgerConfig; strategy: BillingStrategy },
+  scopeId: string,
+): LLMProvider {
+  const { ledger, strategy } = billing;
+
+  async function checkBalanceOrThrow() {
+    const result = await (ledger.Ledger as any).checkBalance({ scopeId });
+    if (!strategy.canExecute(result?.balance ?? 0)) {
+      throw new Error("Insufficient credits");
+    }
+  }
+
+  async function deductUsage(model: string, usage: any) {
+    const adapterPricing = provider.getPricing?.(model);
+    const cost = strategy.calculateCost({ model, usage, adapterPricing });
+    if (cost > 0) {
+      await (ledger.Ledger as any).deduct({
+        scopeId,
+        amount: cost,
+        reason: `AI: ${model}`,
+        model,
+      });
+    }
+  }
+
+  return {
+    ...provider,
+
+    async complete(request: CompletionRequest): Promise<CompletionResult> {
+      await checkBalanceOrThrow();
+      const result = await provider.complete(request);
+      await deductUsage(request.model, result.usage);
+      return result;
+    },
+
+    async streamComplete(
+      request: CompletionRequest,
+      onChunk: (chunk: StreamChunk) => void,
+    ): Promise<CompletionResult> {
+      await checkBalanceOrThrow();
+      const result = await provider.streamComplete(request, onChunk);
+      await deductUsage(request.model, result.usage);
+      return result;
+    },
+  };
+}

package/src/index.ts

@@ -4,13 +4,20 @@ export type { AIConfig } from "./ai-builder";
 
 // --- Tool helper ---
 export { tool, ArcTool } from "./tool/tool";
-export type { ArcToolAny, JsonSchemaToolDef, ToolContext } from "./tool/tool";
+export type {
+  ArcToolAny,
+  JsonSchemaToolDef,
+  ServerToolViewProps,
+  InteractiveToolViewProps,
+} from "./tool/tool";
+
+// --- Credit Ledger ---
+export { creditLedger } from "./aggregates/credit-ledger";
+export type { CreditLedgerConfig } from "./aggregates/credit-ledger";
 
-// --- Aggregate factories & types ---
-export { createCompletionAggregate, createCompletionId } from "./aggregates/completion";
-export type { CompletionAggregate, CompletionId } from "./aggregates/completion";
-export { createBudgetAggregate, createBudgetId } from "./aggregates/budget";
-export type { BudgetAggregate, BudgetId } from "./aggregates/budget";
+// --- Billing strategies ---
+export { fixedMarkupStrategy, flatRateStrategy, tokenPassStrategy } from "./billing";
+export type { BillingStrategy, AdapterPricing } from "./billing";
 
 // --- Provider types ---
 export type {
@@ -28,5 +35,4 @@ export type {
   ToolResult,
   TokenUsage,
   FinishReason,
-  PricingConfig,
 } from "./types";

package/src/tool/tool.ts

@@ -1,12 +1,18 @@
 import {
-  ArcFunction,
-  defaultFunctionData,
-  object,
+  arcFunctionWithCtx,
+  type ArcFunction,
+  type ArcId,
   type ArcRawShape,
-  type $type,
   type ArcContextElement,
   type ArcFunctionData,
+  type ArcObjectAny,
+  type FnContext,
+  type Merge,
+  type $type,
+  type DefaultFunctionData,
+  ArcObject,
 } from "@arcote.tech/arc";
+import type { ComponentType } from "react";
 
 // ─── JSON Schema Tool Definition (sent to LLM) ──────────────────
 
@@ -16,68 +22,153 @@ export interface JsonSchemaToolDef {
   parameters: Record<string, unknown>;
 }
 
-// ─── Tool Context (passed to handle) ────────────────────────────
+// ─── View Props ─────────────────────────────────────────────────
 
-export interface ToolContext {
-  mutate: (element: ArcContextElement<any>) => any;
-  query: (element: ArcContextElement<any>) => any;
-  identifyBy: string;
-}
+export type ServerToolViewProps<P, R> = {
+  params: P;
+  result: R | undefined;
+  calling: boolean;
+  error?: string;
+};
+
+export type InteractiveToolViewProps<P, R> = {
+  params: P;
+  respond: (result: R) => void;
+  calling: boolean;
+};
 
 // ─── ArcTool ─────────────────────────────────────────────────────
 
 export class ArcTool<
   const Name extends string = string,
-  const S extends ArcRawShape = ArcRawShape,
+  Data extends ArcFunctionData = DefaultFunctionData,
+  IdentifyBy = string,
 > {
   readonly name: Name;
-  #fn: ArcFunction<any>;
-  #handler?: (ctx: ToolContext, params: $type<ReturnType<typeof object<S>>>) => Promise<string>;
-
-  constructor(name: Name, fn?: ArcFunction<any>) {
+  readonly #fn: ArcFunction<Data, { identifyBy: IdentifyBy }>;
+  readonly #view?: ComponentType<any>;
+
+  constructor(
+    name: Name,
+    fn?: ArcFunction<any, any>,
+    view?: ComponentType<any>,
+  ) {
     this.name = name;
-    this.#fn = fn ?? new ArcFunction(defaultFunctionData);
+    this.#fn = fn ?? (arcFunctionWithCtx<{ identifyBy: IdentifyBy }>() as any);
+    this.#view = view;
   }
 
+  // ─── Builder methods ──────────────────────────────────────────
+
   description<const D extends string>(desc: D) {
-    const next = new ArcTool<Name, S>(this.name, this.#fn.description(desc));
-    next.#handler = this.#handler;
-    return next;
+    const nextFn = this.#fn.description(desc);
+    return new ArcTool<Name, Merge<Data, { description: D }>, IdentifyBy>(
+      this.name, nextFn as any, this.#view,
+    );
+  }
+
+  withParams<const S extends ArcRawShape>(shape: S) {
+    const nextFn = this.#fn.withParams(shape);
+    return new ArcTool<Name, Merge<Data, { params: ArcObject<S> }>, IdentifyBy>(
+      this.name, nextFn as any, this.#view,
+    );
   }
 
-  schema<const NewS extends ArcRawShape>(shape: NewS) {
-    const next = new ArcTool<Name, NewS>(this.name, this.#fn.withParams(shape));
-    return next;
+  withResult<const S extends ArcRawShape>(shape: S) {
+    const nextFn = this.#fn.withResult(shape);
+    return new ArcTool<Name, Merge<Data, { result: ArcObject<S> }>, IdentifyBy>(
+      this.name, nextFn as any, this.#view,
+    );
   }
 
-  mutate(elements: ArcContextElement<any>[]) {
-    const next = new ArcTool<Name, S>(this.name, this.#fn.mutate(elements));
-    next.#handler = this.#handler;
-    return next;
+  query<const Elements extends ArcContextElement<any>[]>(elements: Elements) {
+    const nextFn = this.#fn.query(elements);
+    return new ArcTool<Name, Merge<Data, { queryElements: Elements }>, IdentifyBy>(
+      this.name, nextFn as any, this.#view,
+    );
   }
 
-  handle(handler: (ctx: ToolContext, params: $type<ReturnType<typeof object<S>>>) => Promise<string>) {
-    const next = new ArcTool<Name, S>(this.name, this.#fn);
-    next.#handler = handler;
-    return next;
+  mutate<const Elements extends ArcContextElement<any>[]>(elements: Elements) {
+    const nextFn = this.#fn.mutate(elements);
+    return new ArcTool<Name, Merge<Data, { mutationElements: Elements }>, IdentifyBy>(
+      this.name, nextFn as any, this.#view,
+    );
   }
 
+  identifyBy<Id extends ArcId<any>>(_id: Id) {
+    return new ArcTool<Name, Data, $type<Id>>(
+      this.name, this.#fn as any, this.#view,
+    );
+  }
+
+  handle<
+    Handler extends
+      | ((
+          ctx: FnContext<Data, { identifyBy: IdentifyBy }>,
+          ...args: Data["params"] extends ArcObjectAny
+            ? [$type<Data["params"]>]
+            : []
+        ) => Promise<any>)
+      | false,
+  >(handler: Handler) {
+    const nextFn = this.#fn.handle(handler as any);
+    return new ArcTool<Name, Merge<Data, { handler: Handler }>, IdentifyBy>(
+      this.name, nextFn as any, this.#view,
+    );
+  }
+
+  view(
+    component: ComponentType<
+      Data["handler"] extends Function
+        ? ServerToolViewProps<
+            Data["params"] extends ArcObjectAny ? $type<Data["params"]> : {},
+            Data["result"] extends ArcObjectAny
+              ? $type<Data["result"]>
+              : unknown
+          >
+        : InteractiveToolViewProps<
+            Data["params"] extends ArcObjectAny ? $type<Data["params"]> : {},
+            Data["result"] extends ArcObjectAny
+              ? $type<Data["result"]>
+              : unknown
+          >
+    >,
+  ) {
+    return new ArcTool<Name, Data, IdentifyBy>(this.name, this.#fn as any, component);
+  }
+
+  // ─── Getters ──────────────────────────────────────────────────
+
   get hasHandler(): boolean {
-    return !!this.#handler;
+    return !!this.#fn.handler;
   }
 
   get isServerTool(): boolean {
     return this.hasHandler;
   }
 
-  get isClientTool(): boolean {
-    return !this.hasHandler;
+  get isInteractiveTool(): boolean {
+    return !this.hasHandler && !!this.#view;
+  }
+
+  get hasView(): boolean {
+    return !!this.#view;
+  }
+
+  get viewComponent(): ComponentType<any> | undefined {
+    return this.#view;
+  }
+
+  get queryElements(): ArcContextElement<any>[] {
+    return this.#fn.data.queryElements || [];
   }
 
   get mutationElements(): ArcContextElement<any>[] {
     return this.#fn.data.mutationElements || [];
   }
 
+  // ─── JSON Schema (for LLM) ───────────────────────────────────
+
   toJsonSchema(): JsonSchemaToolDef {
     const fnSchema = this.#fn.toJsonSchema();
     return {
@@ -87,28 +178,23 @@ export class ArcTool<
     };
   }
 
-  async executeWithContext(params: Record<string, unknown>, ctx: ToolContext): Promise<string> {
-    if (!this.#handler) {
-      throw new Error(`Tool "${this.name}" has no handler`);
-    }
-    return this.#handler(ctx, params as $type<ReturnType<typeof object<S>>>);
-  }
+  // ─── Execution (called by listener) ──────────────────────────
 
-  async execute(params: Record<string, unknown>): Promise<string> {
-    if (!this.#handler) {
+  async executeWithContext(
+    params: Record<string, unknown>,
+    listenerCtx: any,
+    identifyByValue: string,
+  ): Promise<string> {
+    const handler = this.#fn.handler as Function | false | null;
+    if (!handler) {
       throw new Error(`Tool "${this.name}" has no handler`);
     }
-    if (this.mutationElements.length > 0) {
-      throw new Error(
-        `Tool "${this.name}" has mutation dependencies — use executeWithContext() instead`,
-      );
-    }
-    const emptyCtx: ToolContext = {
-      mutate: () => { throw new Error("No mutation context available"); },
-      query: () => { throw new Error("No query context available"); },
-      identifyBy: "",
-    };
-    return this.#handler(emptyCtx, params as $type<ReturnType<typeof object<S>>>);
+
+    const ctx = { ...listenerCtx, identifyBy: identifyByValue };
+    const result = await (handler as Function)(ctx, params);
+
+    if (typeof result === "string") return result;
+    return JSON.stringify(result);
   }
 }
 
@@ -118,4 +204,4 @@ export function tool<const Name extends string>(name: Name) {
   return new ArcTool(name);
 }
 
-export type ArcToolAny = ArcTool<string, ArcRawShape>;
+export type ArcToolAny = ArcTool<string, any, any>;

package/src/types.ts

@@ -48,6 +48,7 @@ export interface CompletionRequest {
   model: string;
   messages: Message[];
   tools?: JsonSchemaToolDef[];
+  toolChoice?: "auto" | "required" | { type: "function"; name: string };
   webSearch?: boolean;
   temperature?: number;
   maxTokens?: number;
@@ -92,6 +93,7 @@ export interface LLMProvider {
     request: CompletionRequest,
     onChunk: (chunk: StreamChunk) => void,
   ): Promise<CompletionResult>;
+  getPricing?(model: string): import("./billing/types").AdapterPricing | undefined;
 }
 
 // ─── Chat Stream (SSE events for chat streaming) ────────────────
@@ -100,7 +102,7 @@ export type ChatStreamEventType =
   | "content_delta"
   | "server_tool_start"
   | "server_tool_result"
-  | "client_tool_request"
+  | "interactive_tool_request"
   | "usage_update"
   | "done"
   | "error";
@@ -118,11 +120,3 @@ export interface ChatStreamEvent {
   error?: string;
 }
 
-// ─── Pricing ─────────────────────────────────────────────────────
-
-export interface PricingConfig {
-  inputPer1M: number;
-  outputPer1M: number;
-  cachedInputPer1M?: number;
-  reasoningPer1M?: number;
-}

package/src/aggregates/budget.ts

@@ -1,137 +0,0 @@
-/// <reference path="../arc.d.ts" />
-import {
-  aggregate,
-  boolean,
-  id,
-  number,
-  string,
-  type ArcId,
-} from "@arcote.tech/arc";
-import type { Token } from "@arcote.tech/arc-auth";
-import type { createCompletionAggregate } from "./completion";
-
-// ─── ID ──────────────────────────────────────────────────────────
-
-export const createBudgetId = <const Name extends string>(data: {
-  name: Name;
-}) => id(`${data.name}Budget`);
-
-export type BudgetId<Name extends string = string> = ReturnType<
-  typeof createBudgetId<Name>
->;
-
-// ─── Aggregate ───────────────────────────────────────────────────
-
-export type BudgetAggregateData = {
-  name: string;
-  budgetId: ArcId<any>;
-  accountId: ArcId<any>;
-  userToken: Token;
-  CompletionAggregate: ReturnType<typeof createCompletionAggregate>;
-};
-
-export const createBudgetAggregate = <
-  const Data extends BudgetAggregateData,
->(
-  data: Data,
-) => {
-  const { budgetId, accountId, userToken, CompletionAggregate } = data;
-
-  const completionFinishedEvent =
-    CompletionAggregate.getEvent("completionFinished");
-
-  return aggregate(`${data.name}Budgets`, budgetId, {
-    accountId,
-    budgetType: string(),
-    limitCents: number(),
-    usedCents: number(),
-    period: string().optional(),
-    isExceeded: boolean(),
-  })
-    .publicEvent(
-      "budgetSet",
-      {
-        budgetId,
-        accountId,
-        budgetType: string(),
-        limitCents: number(),
-        period: string().optional(),
-      },
-      async (ctx, event) => {
-        const p = event.payload;
-        await ctx.set(p.budgetId, {
-          accountId: p.accountId,
-          budgetType: p.budgetType,
-          limitCents: p.limitCents,
-          usedCents: 0,
-          period: p.period,
-          isExceeded: false,
-        });
-      },
-    )
-
-    .publicEvent(
-      "budgetUsageRecorded",
-      {
-        budgetId,
-        amountCents: number(),
-      },
-      async (ctx, event) => {
-        const existing = await ctx.findOne({ _id: event.payload.budgetId });
-        if (!existing) return;
-
-        const newUsed = existing.usedCents + event.payload.amountCents;
-        await ctx.modify(event.payload.budgetId, {
-          usedCents: newUsed,
-          isExceeded: newUsed >= existing.limitCents,
-        });
-      },
-    )
-
-    .handleEvent(completionFinishedEvent, async (ctx, event) => {
-      // Record usage from completion cost on all matching budgets
-      const budgets = await ctx.find({});
-      for (const budget of budgets) {
-        const newUsed = budget.usedCents + event.payload.costCents;
-        await ctx.modify(budget._id, {
-          usedCents: newUsed,
-          isExceeded: newUsed >= budget.limitCents,
-        });
-      }
-    })
-
-    .mutateMethod(
-      "setBudget",
-      (fn) => fn.withParams({
-          budgetType: string(),
-          limitCents: number(),
-          period: string().optional(),
-        }).handle(
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const bId = budgetId.generate();
-          const aId = ctx.$auth.params.accountId;
-
-          await ctx.budgetSet.emit({
-            budgetId: bId,
-            accountId: accountId.parse(aId),
-            budgetType: params.budgetType,
-            limitCents: params.limitCents,
-            period: params.period,
-          });
-
-          return { budgetId: bId };
-        }),
-    ))
-
-    .clientQuery(
-      "getByAccount",
-      (fn) => fn.handle(async (ctx) =>
-        ctx.$query.find({ where: { accountId: ctx.$auth.params.accountId } }),
-    ))
-
-    .protectBy(userToken, (p) => ({ accountId: p.accountId }))
-;
-};
-
-export type BudgetAggregate = ReturnType<typeof createBudgetAggregate>;

package/src/aggregates/completion.ts

@@ -1,235 +0,0 @@
-/// <reference path="../arc.d.ts" />
-import {
-  aggregate,
-  date,
-  id,
-  number,
-  string,
-  type ArcId,
-} from "@arcote.tech/arc";
-import type { Token } from "@arcote.tech/arc-auth";
-import type { LLMProvider, PricingConfig, TokenUsage } from "../types";
-
-// ─── ID ──────────────────────────────────────────────────────────
-
-export const createCompletionId = <const Name extends string>(data: {
-  name: Name;
-}) => id(`${data.name}Completion`);
-
-export type CompletionId<Name extends string = string> = ReturnType<
-  typeof createCompletionId<Name>
->;
-
-// ─── Aggregate ───────────────────────────────────────────────────
-
-export type CompletionAggregateData = {
-  name: string;
-  completionId: ArcId<any>;
-  accountId: ArcId<any>;
-  userToken: Token;
-  providers: LLMProvider[];
-  pricing?: Record<string, PricingConfig>;
-};
-
-export const createCompletionAggregate = <
-  const Data extends CompletionAggregateData,
->(
-  data: Data,
-) => {
-  const { completionId, accountId, userToken, providers, pricing } = data;
-
-  function resolveProvider(model: string): LLMProvider | undefined {
-    return providers.find((p) => p.models.includes(model));
-  }
-
-  function calculateCostCents(
-    model: string,
-    usage: TokenUsage,
-  ): number {
-    const config = pricing?.[model];
-    if (!config) return 0;
-
-    const inputCost =
-      (usage.inputTokens / 1_000_000) * config.inputPer1M;
-    const outputCost =
-      (usage.outputTokens / 1_000_000) * config.outputPer1M;
-    const cachedCost = config.cachedInputPer1M
-      ? (usage.cachedTokens / 1_000_000) * config.cachedInputPer1M
-      : 0;
-    const reasoningCost = config.reasoningPer1M
-      ? (usage.reasoningTokens / 1_000_000) * config.reasoningPer1M
-      : 0;
-
-    return Math.round((inputCost + outputCost + cachedCost + reasoningCost) * 100);
-  }
-
-  return aggregate(
-    `${data.name}Completions`,
-    completionId,
-    {
-      accountId,
-      model: string(),
-      provider: string(),
-      status: string(),
-      promptTokens: number(),
-      completionTokens: number(),
-      totalTokens: number(),
-      costCents: number(),
-      finishReason: string().optional(),
-      errorMessage: string().optional(),
-      requestedAt: date(),
-      completedAt: date().optional(),
-      metadata: string().optional(),
-    },
-  )
-    .publicEvent(
-      "completionRequested",
-      {
-        completionId,
-        accountId,
-        model: string(),
-        provider: string(),
-        metadata: string().optional(),
-      },
-      async (ctx, event) => {
-        const { completionId: cId, accountId: aId, model, provider, metadata } =
-          event.payload;
-        await ctx.set(cId, {
-          accountId: aId,
-          model,
-          provider,
-          status: "pending",
-          promptTokens: 0,
-          completionTokens: 0,
-          totalTokens: 0,
-          costCents: 0,
-          requestedAt: event.createdAt,
-          metadata,
-        });
-      },
-    )
-
-    .publicEvent(
-      "completionFinished",
-      {
-        completionId,
-        promptTokens: number(),
-        completionTokens: number(),
-        totalTokens: number(),
-        costCents: number(),
-        finishReason: string(),
-      },
-      async (ctx, event) => {
-        const p = event.payload;
-        await ctx.modify(p.completionId, {
-          status: "completed",
-          promptTokens: p.promptTokens,
-          completionTokens: p.completionTokens,
-          totalTokens: p.totalTokens,
-          costCents: p.costCents,
-          finishReason: p.finishReason,
-          completedAt: event.createdAt,
-        });
-      },
-    )
-
-    .publicEvent(
-      "completionFailed",
-      {
-        completionId,
-        errorMessage: string(),
-      },
-      async (ctx, event) => {
-        await ctx.modify(event.payload.completionId, {
-          status: "error",
-          errorMessage: event.payload.errorMessage,
-          completedAt: event.createdAt,
-        });
-      },
-    )
-
-    .mutateMethod(
-      "requestCompletion",
-      (fn) => fn.withParams({
-          model: string(),
-          messages: string(),
-          tools: string().optional(),
-          webSearch: string().optional(),
-          metadata: string().optional(),
-        }).handle(
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const provider = resolveProvider(params.model);
-          if (!provider) {
-            return { error: "PROVIDER_NOT_FOUND" as const };
-          }
-
-          const cId = completionId.generate();
-          const aId = ctx.$auth.params.accountId;
-
-          await ctx.completionRequested.emit({
-            completionId: cId,
-            accountId: accountId.parse(aId),
-            model: params.model,
-            provider: provider.name,
-            metadata: params.metadata,
-          });
-
-          try {
-            const messages = JSON.parse(params.messages);
-            const webSearch = params.webSearch === "true";
-
-            const toolDefs = params.tools
-              ? JSON.parse(params.tools) as { name: string; description: string; parameters: Record<string, unknown> }[]
-              : undefined;
-
-            const result = await provider.complete({
-              model: params.model,
-              messages,
-              tools: toolDefs,
-              webSearch,
-            });
-
-            const costCents = calculateCostCents(params.model, result.usage);
-
-            await ctx.completionFinished.emit({
-              completionId: cId,
-              promptTokens: result.usage.inputTokens,
-              completionTokens: result.usage.outputTokens,
-              totalTokens: result.usage.totalTokens,
-              costCents,
-              finishReason: result.finishReason,
-            });
-
-            return {
-              completionId: cId,
-              content: result.content,
-              toolCalls: result.toolCalls,
-              finishReason: result.finishReason,
-            };
-          } catch (error) {
-            const errorMessage =
-              error instanceof Error ? error.message : "Unknown error";
-
-            await ctx.completionFailed.emit({
-              completionId: cId,
-              errorMessage,
-            });
-
-            return { error: errorMessage };
-          }
-        }),
-    ))
-
-    .clientQuery("getAll", (fn) => fn.handle(async (ctx) => ctx.$query.find({})))
-    .clientQuery(
-      "getByAccount",
-      (fn) => fn.handle(async (ctx) =>
-        ctx.$query.find({ where: { accountId: ctx.$auth.params.accountId } }),
-    ))
-
-    .protectBy(userToken, (p) => ({ accountId: p.accountId }))
-;
-};
-
-export type CompletionAggregate = ReturnType<typeof createCompletionAggregate>;

package/src/routes/stream-completion.ts

@@ -1,94 +0,0 @@
-import { route, type ArcAggregateElement } from "@arcote.tech/arc";
-import type { Token } from "@arcote.tech/arc-auth";
-import type { LLMProvider, Message, PricingConfig, StreamChunk } from "../types";
-import type { ArcToolAny } from "../tool/tool";
-
-export type StreamCompletionRouteData = {
-  name: string;
-  completionElement: ArcAggregateElement;
-  userToken: Token;
-  providers: LLMProvider[];
-  pricing?: Record<string, PricingConfig>;
-};
-
-export const createStreamCompletionRoute = <
-  const Data extends StreamCompletionRouteData,
->(
-  data: Data,
-) => {
-  const { completionElement, userToken, providers, pricing } = data;
-
-  function resolveProvider(model: string): LLMProvider | undefined {
-    return providers.find((p) => p.models.includes(model));
-  }
-
-  return route(`${data.name}AiStream`)
-    .path(`/ai/${data.name}/stream/:completionId`)
-    .protectBy(userToken, () => true)
-    .mutate([completionElement])
-    .handle({
-      POST: async (ctx, req) => {
-        const body = await req.json() as {
-          model: string;
-          messages: Message[];
-          tools?: { name: string; description: string; parameters: Record<string, unknown> }[];
-          webSearch?: boolean;
-        };
-
-        const provider = resolveProvider(body.model);
-        if (!provider) {
-          return new Response(
-            JSON.stringify({ error: "PROVIDER_NOT_FOUND" }),
-            { status: 400, headers: { "Content-Type": "application/json" } },
-          );
-        }
-
-        const encoder = new TextEncoder();
-
-        const stream = new ReadableStream({
-          async start(controller) {
-            const sendEvent = (chunk: StreamChunk) => {
-              controller.enqueue(
-                encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`),
-              );
-            };
-
-            try {
-              const result = await provider.streamComplete(
-                {
-                  model: body.model,
-                  messages: body.messages,
-                  tools: body.tools,
-                  webSearch: body.webSearch,
-                },
-                sendEvent,
-              );
-
-              // Send final done event with usage
-              sendEvent({
-                type: "done",
-                usage: result.usage,
-                finishReason: result.finishReason,
-              });
-            } catch (error) {
-              sendEvent({
-                type: "error",
-                content:
-                  error instanceof Error ? error.message : "Unknown error",
-              });
-            } finally {
-              controller.close();
-            }
-          },
-        });
-
-        return new Response(stream, {
-          headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive",
-          },
-        });
-      },
-    });
-};