@cartanova/qgrid-ai-sdk 0.1.0

package/src/index.ts

@@ -0,0 +1,396 @@
+import {
+  type LanguageModelV3,
+  type LanguageModelV3CallOptions,
+  type LanguageModelV3Content,
+  type LanguageModelV3FinishReason,
+  type LanguageModelV3FunctionTool,
+  type LanguageModelV3GenerateResult,
+  type LanguageModelV3StreamPart,
+  type LanguageModelV3StreamResult,
+} from "@ai-sdk/provider";
+
+import {
+  type QgridSupportedModel,
+  type QueryOutput,
+  type QgridProviderConfig,
+} from "./index.types";
+import {
+  extractPromptAndHistory,
+  extractToolResultsFromHistory,
+  parseSSE,
+  toQgridTool,
+} from "./utils";
+
+const DEFAULT_SERVER_URL = "http://localhost:44900";
+const DEFAULT_EFFORT = "low";
+
+export function qgrid(modelId: QgridSupportedModel, config?: QgridProviderConfig): LanguageModelV3 {
+  const serverUrl = config?.serverUrl ?? process.env.QGRID_URL ?? DEFAULT_SERVER_URL;
+  const effort = config?.defaultEffort ?? DEFAULT_EFFORT;
+
+  type ClientRunState = {
+    runContext: { requestLogId: number };
+    pendingToolCallIds: Set<string>;
+  };
+
+  let clientRun: ClientRunState | null = null;
+
+  return {
+    specificationVersion: "v3",
+    provider: "qgrid",
+    modelId,
+    supportedUrls: {},
+
+    async doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult> {
+      const tools = options.tools?.filter(
+        (t): t is LanguageModelV3FunctionTool => t.type === "function",
+      );
+      const hasTools = tools && tools.length > 0;
+      const { prompt, system, history } = extractPromptAndHistory(options.prompt);
+
+      const openaiOpts = options.providerOptions?.openai as Record<string, unknown> | undefined;
+      const effectiveEffort = (openaiOpts?.reasoningEffort as string) ?? effort;
+      const verbosity = (openaiOpts?.textVerbosity ?? openaiOpts?.verbosity) as string | undefined;
+      const reasoningSummary = openaiOpts?.reasoningSummary as string | undefined;
+
+      // top-level이 object인지 검사, 아니면 무시 (SDK 방어로직)
+      const rawSchema =
+        options.responseFormat?.type === "json" ? options.responseFormat.schema : undefined;
+      const schemaType = rawSchema ? (rawSchema as { type?: string }).type : undefined;
+      if (rawSchema && !hasTools && schemaType !== "object") {
+        console.warn(
+          `[qgrid] responseFormat.schema top-level type is "${schemaType ?? "unknown"}". OpenAI structured output requires "object". Falling back to client-side parsing.`,
+        );
+      }
+      const jsonSchema =
+        !hasTools && rawSchema && schemaType === "object" ? JSON.stringify(rawSchema) : undefined;
+
+      // follow-up 판단 + toolResults 구성
+      let runContext: { requestLogId: number } | undefined;
+      let toolResultsPayload:
+        | Array<{ toolCallId: string; output: string; isError?: boolean }>
+        | undefined;
+      let logMode: "auto" | "run" | undefined;
+
+      if (clientRun) {
+        const toolResults = extractToolResultsFromHistory(options.prompt);
+        const resultIds = new Set(toolResults.map((r) => r.callId));
+        if (
+          clientRun.pendingToolCallIds.size > 0 &&
+          [...clientRun.pendingToolCallIds].every((id) => resultIds.has(id))
+        ) {
+          // follow-up
+          runContext = clientRun.runContext;
+          toolResultsPayload = toolResults
+            .filter((r) => clientRun!.pendingToolCallIds.has(r.callId))
+            .map((r) => ({ toolCallId: r.callId, output: r.result }));
+          logMode = "run";
+        } else {
+          console.warn(
+            "[qgrid] pending tool results not found in prompt, clearing client run state",
+          );
+          clientRun = null;
+        }
+      }
+
+      if (!logMode && hasTools) logMode = "run";
+
+      const data = await fetch(`${serverUrl}/api/qgrid/query`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          args: {
+            prompt,
+            model: modelId,
+            system,
+            effort: effectiveEffort,
+            ...(verbosity ? { verbosity } : {}),
+            ...(reasoningSummary ? { reasoningSummary } : {}),
+            ...(hasTools ? { tools: tools.map(toQgridTool) } : {}),
+            ...(jsonSchema ? { jsonSchema } : {}),
+            ...(history.length > 0 ? { history: JSON.stringify(history) } : {}),
+            ...(logMode ? { logMode } : {}),
+            ...(runContext ? { runContext } : {}),
+            ...(toolResultsPayload ? { toolResults: toolResultsPayload } : {}),
+          },
+        }),
+        signal: options.abortSignal,
+      }).then(async (res) => {
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw new Error(`qgrid ${res.status}: ${text}`);
+        }
+        return (await res.json()) as QueryOutput;
+      });
+
+      // 응답 변환
+      const content: LanguageModelV3Content[] = [];
+      let finishReason: LanguageModelV3FinishReason = { unified: "stop", raw: "stop" };
+      if (data.content) {
+        for (const item of data.content) {
+          if (item.type === "text") content.push({ type: "text", text: item.text });
+          else
+            content.push({
+              type: "tool-call",
+              toolCallId: item.toolCallId,
+              toolName: item.toolName,
+              input: item.input,
+            });
+        }
+        if (data.finishReason === "tool-calls")
+          finishReason = { unified: "tool-calls", raw: "tool_call" };
+      } else {
+        content.push({ type: "text", text: data.text });
+      }
+
+      // client run state 업데이트
+      if (data.runContext && finishReason.unified === "tool-calls") {
+        clientRun = {
+          runContext: data.runContext,
+          pendingToolCallIds: new Set(
+            content
+              .filter(
+                (c): c is Extract<LanguageModelV3Content, { type: "tool-call" }> =>
+                  c.type === "tool-call",
+              )
+              .map((c) => c.toolCallId),
+          ),
+        };
+      } else {
+        clientRun = null;
+      }
+
+      return {
+        content,
+        finishReason,
+        usage: {
+          inputTokens: {
+            total: data.usage.input_tokens,
+            noCache: data.usage.input_tokens - data.usage.cache_read_input_tokens,
+            cacheRead: data.usage.cache_read_input_tokens,
+            cacheWrite: data.usage.cache_creation_input_tokens,
+          },
+          outputTokens: {
+            total: data.usage.output_tokens,
+            text: data.usage.output_tokens,
+            reasoning: undefined,
+          },
+        },
+        warnings: [],
+        providerMetadata: {
+          qgrid: {
+            model: data.model,
+            tokenName: data.tokenName ?? null,
+            durationMs: data.durationMs,
+            costUsd: data.costUsd,
+          },
+        },
+        response: { modelId: data.model },
+      };
+    },
+
+    async doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult> {
+      const tools = options.tools?.filter(
+        (t): t is LanguageModelV3FunctionTool => t.type === "function",
+      );
+      const hasTools = tools && tools.length > 0;
+      const { prompt, system, history } = extractPromptAndHistory(options.prompt);
+
+      const openaiOpts = options.providerOptions?.openai as Record<string, unknown> | undefined;
+      const effectiveEffort = (openaiOpts?.reasoningEffort as string) ?? effort;
+      const verbosity = (openaiOpts?.textVerbosity ?? openaiOpts?.verbosity) as string | undefined;
+      const reasoningSummary = openaiOpts?.reasoningSummary as string | undefined;
+
+      const rawSchema =
+        options.responseFormat?.type === "json" ? options.responseFormat.schema : undefined;
+      const jsonSchema =
+        !hasTools && rawSchema && (rawSchema as { type?: string }).type === "object"
+          ? JSON.stringify(rawSchema)
+          : undefined;
+
+      // follow-up 판단
+      let runContext: { requestLogId: number } | undefined;
+      let toolResultsPayload:
+        | Array<{ toolCallId: string; output: string; isError?: boolean }>
+        | undefined;
+
+      if (clientRun) {
+        const toolResults = extractToolResultsFromHistory(options.prompt);
+        const resultIds = new Set(toolResults.map((r) => r.callId));
+        if (
+          clientRun.pendingToolCallIds.size > 0 &&
+          [...clientRun.pendingToolCallIds].every((id) => resultIds.has(id))
+        ) {
+          runContext = clientRun.runContext;
+          toolResultsPayload = toolResults
+            .filter((r) => clientRun!.pendingToolCallIds.has(r.callId))
+            .map((r) => ({ toolCallId: r.callId, output: r.result }));
+        } else {
+          console.warn(
+            "[qgrid] pending tool results not found in prompt, clearing client run state",
+          );
+          clientRun = null;
+        }
+      }
+
+      const prepRes = await fetch(`${serverUrl}/api/qgrid/prepareStream`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          args: {
+            prompt,
+            model: modelId,
+            system,
+            effort: effectiveEffort,
+            ...(verbosity ? { verbosity } : {}),
+            ...(reasoningSummary ? { reasoningSummary } : {}),
+            ...(hasTools ? { tools: tools.map(toQgridTool) } : {}),
+            ...(jsonSchema ? { jsonSchema } : {}),
+            ...(history.length > 0 ? { history: JSON.stringify(history) } : {}),
+            logMode: "run",
+            ...(runContext ? { runContext } : {}),
+            ...(toolResultsPayload ? { toolResults: toolResultsPayload } : {}),
+          },
+        }),
+        signal: options.abortSignal,
+      });
+      if (!prepRes.ok) {
+        const text = await prepRes.text().catch(() => "");
+        throw new Error(`qgrid prepareStream ${prepRes.status}: ${text}`);
+      }
+      const { streamId } = (await prepRes.json()) as { streamId: string };
+
+      const streamRes = await fetch(`${serverUrl}/api/qgrid/queryStream?streamId=${streamId}`, {
+        signal: options.abortSignal,
+      });
+      if (!streamRes.ok || !streamRes.body) {
+        const text = await streamRes.text().catch(() => "");
+        throw new Error(`qgrid stream ${streamRes.status}: ${text}`);
+      }
+
+      const textId = `text_${Math.random().toString(36).slice(2, 10)}`;
+      let textStarted = false;
+      let deltaTextEmitted = false;
+
+      const stream = new ReadableStream<LanguageModelV3StreamPart>({
+        async start(controller) {
+          try {
+            let streamCompleted = false;
+            for await (const event of parseSSE(streamRes.body!)) {
+              if (event.type === "delta") {
+                if (!hasTools) {
+                  if (!textStarted) {
+                    controller.enqueue({ type: "text-start", id: textId });
+                    textStarted = true;
+                  }
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: textId,
+                    delta: (event.data as { text: string }).text,
+                  });
+                  deltaTextEmitted = true;
+                }
+              } else if (event.type === "done") {
+                if (textStarted) {
+                  controller.enqueue({ type: "text-end", id: textId });
+                  textStarted = false;
+                }
+                const done = event.data as QueryOutput;
+
+                // client run state 업데이트
+                if (done.runContext && done.finishReason === "tool-calls") {
+                  clientRun = {
+                    runContext: done.runContext,
+                    pendingToolCallIds: new Set(
+                      (done.content ?? [])
+                        .filter(
+                          (
+                            c,
+                          ): c is Extract<
+                            NonNullable<QueryOutput["content"]>[number],
+                            { type: "tool-call" }
+                          > => c.type === "tool-call",
+                        )
+                        .map((c) => c.toolCallId),
+                    ),
+                  };
+                } else {
+                  clientRun = null;
+                }
+
+                // AI SDK stream parts
+                if (done.content) {
+                  for (const item of done.content) {
+                    if (item.type === "text" && !deltaTextEmitted) {
+                      const tid = `text_${Math.random().toString(36).slice(2, 10)}`;
+                      controller.enqueue({ type: "text-start", id: tid });
+                      controller.enqueue({ type: "text-delta", id: tid, delta: item.text });
+                      controller.enqueue({ type: "text-end", id: tid });
+                    } else if (item.type === "tool-call") {
+                      controller.enqueue({
+                        type: "tool-input-start",
+                        id: item.toolCallId,
+                        toolName: item.toolName,
+                      });
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: item.toolCallId,
+                        delta: item.input,
+                      });
+                      controller.enqueue({ type: "tool-input-end", id: item.toolCallId });
+                      controller.enqueue({
+                        type: "tool-call",
+                        toolCallId: item.toolCallId,
+                        toolName: item.toolName,
+                        input: item.input,
+                      });
+                    }
+                  }
+                }
+
+                controller.enqueue({
+                  type: "finish",
+                  finishReason:
+                    done.finishReason === "tool-calls"
+                      ? { unified: "tool-calls", raw: "tool_call" }
+                      : { unified: "stop", raw: "stop" },
+                  usage: {
+                    inputTokens: {
+                      total: done.usage.input_tokens,
+                      noCache: done.usage.input_tokens - done.usage.cache_read_input_tokens,
+                      cacheRead: done.usage.cache_read_input_tokens,
+                      cacheWrite: done.usage.cache_creation_input_tokens,
+                    },
+                    outputTokens: {
+                      total: done.usage.output_tokens,
+                      text: done.usage.output_tokens,
+                      reasoning: undefined,
+                    },
+                  },
+                });
+                streamCompleted = true;
+                controller.close();
+                return;
+              } else if (event.type === "error") {
+                streamCompleted = true;
+                controller.error(new Error((event.data as { message: string }).message));
+                return;
+              }
+            }
+            if (!streamCompleted) {
+              controller.error(new Error("qgrid stream ended unexpectedly"));
+            }
+          } catch (e) {
+            controller.error(e);
+          }
+        },
+      });
+
+      return { stream };
+    },
+  };
+}
+
+export { createQgridLogger } from "./logger";
+export type { QgridLoggerConfig, QgridProviderOptions } from "./index.types";
+export default qgrid;

package/src/index.types.ts

@@ -0,0 +1,131 @@
+export type QgridProviderConfig = {
+  serverUrl?: string;
+  defaultEffort?: string;
+};
+
+/**
+ * codex app-server가 지원하는 OpenAI provider options.
+ *
+ * AI SDK의 openai provider options 중 codex가 처리할 수 있는 subset만 정의.
+ * 여기에 없는 옵션(temperature, maxOutputTokens 등)은 codex가 무시합니다.
+ *
+ * @see https://ai-sdk.dev/providers/ai-sdk-providers/openai#provider-options
+ */
+type QgridOpenAIProviderOptions = {
+  /** reasoning 모델의 추론 깊이. 기본값은 qgrid config의 defaultEffort. */
+  reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+  /** reasoning 모델의 추론 요약 출력 방식. Responses API 전용. */
+  reasoningSummary?: "auto" | "concise" | "detailed" | "none";
+  /** 응답 텍스트의 상세도. */
+  textVerbosity?: "low" | "medium" | "high";
+};
+
+/**
+ * {@link QgridOpenAIProviderOptions}
+ */
+export type QgridProviderOptions = {
+  openai?: QgridOpenAIProviderOptions;
+};
+
+export type QgridSupportedModel =
+  | "openai/gpt-5.5"
+  | "openai/gpt-5.4"
+  | "openai/gpt-5.2"
+  | "openai/gpt-5.4-mini"
+  | "openai/gpt-5.3-codex"
+  | "openai/gpt-5.3-codex-spark"
+  | "anthropic/claude-haiku-4-5"
+  | "anthropic/claude-sonnet-4"
+  | "anthropic/claude-sonnet-4-5"
+  | "anthropic/claude-sonnet-4-6"
+  | "anthropic/claude-sonnet-4-7"
+  | "anthropic/claude-opus-4"
+  | "anthropic/claude-opus-4-1"
+  | "anthropic/claude-opus-4-5"
+  | "anthropic/claude-opus-4-6"
+  | "anthropic/claude-opus-4-7";
+
+// 아래 타입들은 Qgrid에서 생성된 type을 그대로 가져와서 사용합니다.
+export type QueryOutput = {
+  text: string;
+  content?: Array<
+    | { type: "text"; text: string }
+    | { type: "tool-call"; toolCallId: string; toolName: string; input: string }
+  >;
+  finishReason?: "stop" | "tool-calls";
+  model: string;
+  tokenName?: string;
+  usage: {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+  };
+  durationMs: number;
+  costUsd: number;
+  runContext?: { requestLogId: number };
+};
+
+export type CreateRunInput = {
+  userPrompt: string;
+  systemPrompt?: string;
+  modelName?: string;
+  effort?: string;
+  projectName?: string;
+};
+
+export type AppendStepInput = {
+  requestLogId: number;
+  stepIndex: number;
+  type: "generate" | "tool_call";
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheCreationTokens?: number;
+  durationMs?: number;
+  finishReason?: string;
+  reasoningText?: string;
+  reasoningTokens?: number;
+  toolCallIndex?: number;
+  toolCallId?: string;
+  toolName?: string;
+  toolArgs?: string;
+  toolResult?: string;
+  toolDurationMs?: number;
+  error?: string;
+};
+
+export type QgridLoggerConfig = {
+  serverUrl: string;
+  projectName?: string;
+  tokenName?: string;
+  /**
+   * Fallback timeout for runs that receive onStart but never receive onFinish.
+   * AI SDK TelemetryIntegration does not expose an error hook, so provider
+   * failures before a final step can otherwise leave request logs running.
+   *
+   * Set to 0 to disable. Defaults to 30 minutes, or the AI SDK total timeout
+   * plus a short grace period when one is provided.
+   */
+  staleRunTimeoutMs?: number;
+  /**
+   * Receives qgrid logging failures. When reusing one logger integration across
+   * overlapping AI SDK calls, pass a unique `metadata.qgridRunId` per call so
+   * lifecycle events can be attributed to the correct run.
+   */
+  onLogError?: (error: Error) => void;
+};
+
+export type FinishRunInput = {
+  requestLogId: number;
+  status: "succeeded" | "error" | "aborted";
+  response?: string;
+  tokenName?: string;
+  totalInputTokens?: number;
+  totalOutputTokens?: number;
+  totalCacheReadTokens?: number;
+  totalCacheCreationTokens?: number;
+  totalDurationMs?: number;
+  history?: string;
+  errorMessage?: string;
+};