@copilotkit/runtime 0.0.0-feat-dynamic-copilotcloud-qa-20250117190454

package/src/service-adapters/unify/unify-adapter.ts

@@ -0,0 +1,145 @@
+/**
+ * CopilotKit Adapter for Unify
+ *
+ * <RequestExample>
+ * ```jsx CopilotRuntime Example
+ * const copilotKit = new CopilotRuntime();
+ * return copilotKit.response(req, new UnifyAdapter());
+ * ```
+ * </RequestExample>
+ *
+ * You can easily set the model to use by passing it to the constructor.
+ * ```jsx
+ * const copilotKit = new CopilotRuntime();
+ * return copilotKit.response(
+ *   req,
+ *   new UnifyAdapter({ model: "llama-3-8b-chat@fireworks-ai" }),
+ * );
+ * ```
+ */
+import { TextMessage } from "../../graphql/types/converted";
+import {
+  CopilotRuntimeChatCompletionRequest,
+  CopilotRuntimeChatCompletionResponse,
+  CopilotServiceAdapter,
+} from "../service-adapter";
+import OpenAI from "openai";
+import { randomId } from "@copilotkit/shared";
+import { convertActionInputToOpenAITool, convertMessageToOpenAIMessage } from "../openai/utils";
+
+export interface UnifyAdapterParams {
+  apiKey?: string;
+  model: string;
+}
+
+export class UnifyAdapter implements CopilotServiceAdapter {
+  private apiKey: string;
+  private model: string;
+  private start: boolean;
+
+  constructor(options?: UnifyAdapterParams) {
+    if (options?.apiKey) {
+      this.apiKey = options.apiKey;
+    } else {
+      this.apiKey = "UNIFY_API_KEY";
+    }
+    this.model = options?.model;
+    this.start = true;
+  }
+
+  async process(
+    request: CopilotRuntimeChatCompletionRequest,
+  ): Promise<CopilotRuntimeChatCompletionResponse> {
+    const tools = request.actions.map(convertActionInputToOpenAITool);
+    const openai = new OpenAI({
+      apiKey: this.apiKey,
+      baseURL: "https://api.unify.ai/v0/",
+    });
+    const forwardedParameters = request.forwardedParameters;
+
+    const messages = request.messages.map(convertMessageToOpenAIMessage);
+
+    const stream = await openai.chat.completions.create({
+      model: this.model,
+      messages: messages,
+      stream: true,
+      ...(tools.length > 0 && { tools }),
+      ...(forwardedParameters?.temperature && { temperature: forwardedParameters.temperature }),
+    });
+
+    let model = null;
+    let currentMessageId: string;
+    let currentToolCallId: string;
+    request.eventSource.stream(async (eventStream$) => {
+      let mode: "function" | "message" | null = null;
+      for await (const chunk of stream) {
+        if (this.start) {
+          model = chunk.model;
+          currentMessageId = randomId();
+          eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+          eventStream$.sendTextMessageContent({
+            messageId: currentMessageId,
+            content: `Model used: ${model}\n`,
+          });
+          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+          this.start = false;
+        }
+        const toolCall = chunk.choices[0].delta.tool_calls?.[0];
+        const content = chunk.choices[0].delta.content;
+
+        // When switching from message to function or vice versa,
+        // send the respective end event.
+        // If toolCall?.id is defined, it means a new tool call starts.
+        if (mode === "message" && toolCall?.id) {
+          mode = null;
+          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+        } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
+          mode = null;
+          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+        }
+
+        // If we send a new message type, send the appropriate start event.
+        if (mode === null) {
+          if (toolCall?.id) {
+            mode = "function";
+            currentToolCallId = toolCall!.id;
+            eventStream$.sendActionExecutionStart({
+              actionExecutionId: currentToolCallId,
+              actionName: toolCall!.function!.name,
+            });
+          } else if (content) {
+            mode = "message";
+            currentMessageId = chunk.id;
+            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+          }
+        }
+
+        // send the content events
+        if (mode === "message" && content) {
+          eventStream$.sendTextMessageContent({
+            messageId: currentMessageId,
+            content: content,
+          });
+        } else if (mode === "function" && toolCall?.function?.arguments) {
+          eventStream$.sendActionExecutionArgs({
+            actionExecutionId: currentToolCallId,
+            args: toolCall.function.arguments,
+          });
+        }
+      }
+
+      // send the end events
+      if (mode === "message") {
+        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+      } else if (mode === "function") {
+        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+      }
+
+      eventStream$.complete();
+    });
+
+    return {
+      threadId: request.threadId || randomId(),
+    };
+  }
+}

package/src/utils/failed-response-status-reasons.ts

@@ -0,0 +1,48 @@
+import {
+  FailedResponseStatus,
+  FailedResponseStatusReason,
+} from "../graphql/types/response-status.type";
+
+export class GuardrailsValidationFailureResponse extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.GUARDRAILS_VALIDATION_FAILED;
+  declare details: {
+    guardrailsReason: string;
+  };
+
+  constructor({ guardrailsReason }) {
+    super();
+    this.details = {
+      guardrailsReason,
+    };
+  }
+}
+
+export class MessageStreamInterruptedResponse extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.MESSAGE_STREAM_INTERRUPTED;
+  declare details: {
+    messageId: string;
+    description: string;
+  };
+
+  constructor({ messageId }: { messageId: string }) {
+    super();
+    this.details = {
+      messageId,
+      description: "Check the message for mode details",
+    };
+  }
+}
+
+export class UnknownErrorResponse extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.UNKNOWN_ERROR;
+  declare details: {
+    description?: string;
+  };
+
+  constructor({ description }: { description?: string }) {
+    super();
+    this.details = {
+      description,
+    };
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from "./failed-response-status-reasons";

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../utilities/tsconfig/base.json",
+  "compilerOptions": {
+    "lib": ["es2017", "dom"],
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "strict": false,
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["dist", "build", "node_modules", "**/*.test.ts", "**/*.test.tsx", "**/__tests__/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig, Options } from "tsup";
+
+export default defineConfig((options: Options) => ({
+  ...options,
+  entry: ["src/**/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  minify: false,
+  external: [],
+  sourcemap: true,
+  exclude: [
+    "**/*.test.ts", // Exclude TypeScript test files
+    "**/*.test.tsx", // Exclude TypeScript React test files
+    "**/__tests__/*", // Exclude any files inside a __tests__ directory
+  ],
+}));

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.ts"]
+}