import { createClientFromRequest } from "npm:@base44/sdk@0.8.52";
import { ToolLoopAgent, tool, stepCountIs, hasToolCall } from "npm:ai@7.0.16";
import { createOpenAICompatible } from "npm:@ai-sdk/openai-compatible@3.0.5";
import { z } from "npm:zod@4.4.3";

export default async function (req) {
  const base44 = createClientFromRequest(req);
  const user = await base44.auth.me();
  if (!user) return Response.json({ error: "Unauthorized" }, { status: 401 });

  const { return_id } = await req.json();
  const request = await base44.entities.ReturnRequest.get(return_id);

  const { baseURL, token, headers } = base44.asServiceRole.aiGateway.connection();
  const base44Models = createOpenAICompatible({ name: "base44", baseURL, apiKey: token, headers });

  const agent = new ToolLoopAgent({
    model: base44Models("automatic"),
    instructions:
      "Decide whether this return looks fine or needs the owner's attention. " +
      "Check the customer's past orders as many times as you need, then submit your verdict.",
    tools: {
      searchOrders: tool({
        description: "This customer's past orders, optionally filtered by status",
        inputSchema: z.object({ status: z.string().optional() }),
        execute: ({ status }) => {
          const query = { customer_email: request.customer_email };
          if (status) query.status = status;
          return base44.entities.Order.filter(query, "-created_date", 50);
        },
      }),
      submitVerdict: tool({
        description: "Record the final verdict. Call this once, when you've decided.",
        inputSchema: z.object({ decision: z.enum(["approved", "flagged"]), reason: z.string() }),
        execute: ({ decision, reason }) =>
          base44.entities.ReturnRequest.update(return_id, { status: decision, review_note: reason }),
      }),
    },
    // stops at the first to trigger — submitVerdict was called, or 8 steps elapsed;
    // mix whatever conditions fit the task (a step cap, a finish tool, a custom condition)
    stopWhen: [stepCountIs(8), hasToolCall("submitVerdict")],
  });

  await agent.generate({ prompt: `Review this return request: ${JSON.stringify(request)}` });
  return Response.json({ ok: true });
}

const { text } = await agent.generate({ messages: [{ role: "user", content: [
  { type: "text", text: `Review this receipt: ${JSON.stringify(receipt)}` },
  { type: "image", image: receipt.image_url },
]}]});

import OpenAI from "npm:openai@6.45.0";

const { baseURL, token, headers } = base44.asServiceRole.aiGateway.connection();
const client = new OpenAI({ baseURL, apiKey: token, defaultHeaders: headers, maxRetries: 0 });

const { data, usage } = await client.images.generate({
  model: "automatic",
  prompt: `${description}. Studio lighting.`,
  n: 1,                         // up to 4 per request; some models allow fewer
  response_format: "url",       // "url" or "b64_json"; default "b64_json"
  // Base44 extensions beyond the OpenAI spec:
  aspect_ratio: "16:9",
  resolution: "1K",             // higher resolutions are model-specific
  reference_image_urls: [url],  // image inputs by URL
});
// data[0].url is the stored image URL; usage.base44_credits is the charged amount.

import { createClientFromRequest } from "npm:@base44/sdk@0.8.52";
import OpenAI from "npm:openai@6.45.0";

export default async function (req) {
  const base44 = createClientFromRequest(req);
  const user = await base44.auth.me();
  if (!user) return Response.json({ error: "Unauthorized" }, { status: 401 });

  const { action, prompt, videoId } = await req.json();
  const { baseURL, token, headers } = base44.asServiceRole.aiGateway.connection();
  const { videos } = new OpenAI({ baseURL, apiKey: token, defaultHeaders: headers });

  if (action === "create") {
    // The function picks the model and duration; the browser only sends the prompt.
    const job = await videos.create(
      { model: "veo_3_1_lite", prompt, seconds: 4, generate_audio: false },
      { maxRetries: 0 },
    );
    return Response.json(job, { status: 202 });
  }
  if (action === "retrieve") {
    return Response.json(await videos.retrieve(videoId));
  }
  return Response.json({ error: "Invalid action" }, { status: 400 });
}

const isProcessing = (status) => status === "queued" || status === "in_progress";

let { data: video } = await base44.functions.invoke("video-gateway", { action: "create", prompt });
for (let attempt = 0; isProcessing(video.status) && attempt < 40; attempt += 1) {
  await new Promise((resolve) => setTimeout(resolve, 15_000));
  ({ data: video } = await base44.functions.invoke("video-gateway", {
    action: "retrieve",
    videoId: video.id,
  }));
}
if (video.status === "failed") throw new Error(video.error?.message || "Video generation failed");
// video.url is the stored video once status is "completed"

import OpenAI from "npm:openai";

const { baseURL, token, headers } = base44.asServiceRole.aiGateway.connection();
const client = new OpenAI({ baseURL, apiKey: token, defaultHeaders: headers, maxRetries: 0 });
const speechRequest = {
  model: "gpt_4o_mini_tts",
  input: text,
  voice: "nova",
};
const audio = await client.audio.speech.create(speechRequest);
const credits = Number(audio.headers.get("x-base44-credits"));
const file = new File([await audio.arrayBuffer()], "speech.mp3", { type: "audio/mpeg" });
const { file_uri } = await base44.asServiceRole.integrations.Core.UploadPrivateFile({ file });
return Response.json({ file_uri, credits });

const estimate = await client.post("/audio/speech", {
  body: { ...speechRequest, dry_run: true },
});
const estimatedCredits = estimate.usage.base44_credits;

import { createClientFromRequest } from "npm:@base44/sdk@0.8.52";
import { experimental_evaluate as evaluate } from "npm:ai@7.0.105";
import { createTypeSafeAi } from "npm:@ai-sdk/typesafe-ai@3.0.4";

export default async function (req) {
  const base44 = createClientFromRequest(req);
  const user = await base44.auth.me();
  if (!user) return Response.json({ error: "Unauthorized" }, { status: 401 });

  const { message } = await req.json();
  const { baseURL, token, headers } = base44.asServiceRole.aiGateway.connection({ provider: "typesafe" });
  const typesafe = createTypeSafeAi({ baseURL, apiKey: token, headers });

  const result = await evaluate({
    model: typesafe.evaluationModel("jev"),
    maxRetries: 0, // avoid automatic replays of billed requests
    state: { message },
    questions: {
      department: { type: "choice", instructions: "Which team should handle this?",
        criteria: { billing: "Payments and refunds", support: "Other requests" } },
      urgency: { type: "score", instructions: "How urgent is this?",
        criteria: ["No deadline", "Requested today", "Immediate emergency"] },
      refund: { type: "boolean", instructions: "Is a refund explicitly requested?" },
    },
  });
  return Response.json({ answers: result.answers });
}

{
  answers: {
    department: { type: "choice", choice: "billing", probabilities: { billing: 0.97, support: 0.03 } },
    urgency: { type: "score", score: 1.2, probabilities: { 0: 0.1, 1: 0.6, 2: 0.3 } }, // 0..criteria.length-1, may be fractional
    refund: { type: "boolean", probability: 0.99 }, // P(true)
  },
  providerMetadata: {
    typesafe: { confidence: { department: 0.9, urgency: 0.7 } }, // choice/score only; entries may be absent
  },
}

/** Connection details for the Base44 AI Gateway. */
interface AiGatewayConnection {
  /** Base URL of the selected gateway provider. */
  baseURL: string;
  /** Bearer token for the gateway. Empty string when the caller is unauthenticated. */
  token: string;
  /**
   * Extra headers to send with every gateway request (`defaultHeaders` for the `openai`
   * SDK, `headers` for Vercel AI SDK providers). On a client from
   * `createClientFromRequest()` this carries the signed `Base44-State` a workspace IP
   * allowlist requires; otherwise it's empty.
   */
  headers: Record<string, string>;
}

/** Options for selecting an AI Gateway provider. */
interface AiGatewayConnectionOptions {
  /** Gateway provider to connect to. Defaults to `openai`. */
  provider?: "openai" | "typesafe";
}

interface AiGatewayModule {
  connection(options?: AiGatewayConnectionOptions): AiGatewayConnection;
}