@arcote.tech/arc-ai 0.5.1 → 0.5.5

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",
-          },
-        });
-      },
-    });
-};