AI Transport providers

// server/api/chat.post.ts
import { streamText, toUIMessageStream } from "ai";
import { createAgentSession } from "@sockudo/ai-transport/vercel";
import { realtimeClient } from "../utils/sockudo";

export default defineEventHandler(async (event) => {
  const body = await readBody(event);

  const session = createAgentSession({
    client: realtimeClient(),
    channelName: body.channelName,
  });

  const run = session.createRun({
    runId: body.runId,
    invocationId: body.invocationId,
    inputEventId: body.inputEventId,
    clientId: body.clientId,
    onCancel(request) {
      return (
        request.filter.all === true ||
        request.matchedRunIds.includes(body.runId)
      );
    },
  });

  event.waitUntil?.(
    (async () => {
      await run.start();
      const result = streamText({
        model: "openai/gpt-5-mini",
        instructions: "You are a concise incident-room assistant.",
        prompt:
          body.messages
            .at(-1)
            ?.parts?.map((part) => part.text ?? "")
            .join("") ?? "",
        abortSignal: run.abortSignal,
      });
      await run.streamResponse(toUIMessageStream({ stream: result.stream }));
      await run.end("complete");
      session.close();
    })(),
  );

  setResponseStatus(event, 202);
});

import { useChat } from "@ai-sdk/vue";
import { provideChatTransport } from "@sockudo/ai-transport/vercel/vue";

const provider = provideChatTransport({
  api: "/api/chat",
  channelName: "private-ai:user-42:sess-01J",
  client: sockudoClient,
  clientId: "user-42",
});

const { sendMessage } = useChat({
  id: "private-ai:user-42:sess-01J",
  transport: provider.chatTransport.value,
});

await sendMessage({ text: "Summarize the last deploy failure." });

import {
  createOpenAICompatibleProvider,
  runDirectLlm,
} from "@sockudo/ai-transport/providers";

const provider = createOpenAICompatibleProvider({
  provider: "groq",
  apiKey: process.env.GROQ_API_KEY,
  model: "llama-3.3-70b-versatile",
});

await runDirectLlm(run, provider, {
  prompt: "Write a remediation plan for a Redis fanout incident.",
  maxOutputTokens: 800,
});

import OpenAI from "openai";
import {
  createOpenAISdkProvider,
  runDirectLlm,
} from "@sockudo/ai-transport/providers";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const chatProvider = createOpenAISdkProvider({
  client: openai,
  mode: "chat",
  model: "gpt-4.1-mini",
});

await runDirectLlm(run, chatProvider, {
  messages: [
    { role: "system", content: "Answer as a production engineer." },
    { role: "user", content: "Why did reconnect recovery fail?" },
  ],
});

const responsesProvider = createOpenAISdkProvider({
  client: openai,
  mode: "responses",
  model: "gpt-5-mini",
});

await runDirectLlm(run, responsesProvider, {
  prompt: "Explain the latest channel history page in plain English.",
  body: {
    reasoning: { effort: "low" },
  },
});

import Anthropic from "@anthropic-ai/sdk";
import {
  createAnthropicSdkProvider,
  runDirectLlm,
} from "@sockudo/ai-transport/providers";

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

const provider = createAnthropicSdkProvider({
  client: anthropic,
  model: "claude-sonnet-4-5",
  system: "Be concise and include risk levels.",
});

await runDirectLlm(run, provider, {
  prompt: "Audit this failed push notification delivery chain.",
});

import {
  createAnthropicSdkProvider,
  createDirectLlmProviderRegistry,
  createOpenAICompatibleProvider,
} from "@sockudo/ai-transport/providers";

const providers = createDirectLlmProviderRegistry({
  groq: createOpenAICompatibleProvider({
    provider: "groq",
    apiKey: process.env.GROQ_API_KEY,
    model: "llama-3.3-70b-versatile",
  }),
  local: createOpenAICompatibleProvider({
    provider: "ollama",
    model: "llama3.2",
  }),
  anthropic: createAnthropicSdkProvider({
    client: anthropic,
    model: "claude-sonnet-4-5",
  }),
});

const stream = await providers.streamText("local", {
  prompt: "Return a JSON incident summary.",
});

import type { DirectLlmProvider } from "@sockudo/ai-transport/providers";

const provider: DirectLlmProvider = {
  async streamText(request) {
    const words = (request.prompt ?? "").split(/\s+/);

    return new ReadableStream({
      start(controller) {
        controller.enqueue({ type: "start" });
        controller.enqueue({ type: "text-start", id: "answer" });
        for (const word of words) {
          controller.enqueue({
            type: "text-delta",
            id: "answer",
            delta: `${word} `,
          });
        }
        controller.enqueue({ type: "text-end", id: "answer" });
        controller.enqueue({ type: "finish", finishReason: "stop" });
        controller.close();
      },
    });
  },
};