@buyong/pi-devin 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buyong/pi-devin",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "Unofficial Pi provider for Devin accounts (OAuth)",
   "license": "MIT",

package/src/core/inference/chat.ts

@@ -60,6 +60,10 @@ export function chatRequest(options: {
   };
 }
 
+// Backends mark a finished turn differently: Anthropic text ends with MIN_LOG_PROB, Gemini tool calls with STOP_PATTERN,
+// and OpenAI sends no stop reason (UNSPECIFIED is the proto3 default, so it is not on the wire).
+const COMPLETE_STOP_REASONS = new Set(["STOP_REASON_STOP_PATTERN", "STOP_REASON_FUNCTION_CALL", "STOP_REASON_MIN_LOG_PROB", "STOP_REASON_UNSPECIFIED", ""]);
+
 /** Attaches argument deltas without an ID to the call that started with the first ID. Ambiguous parallel deltas are rejected. */
 export class ChatAccumulator {
   readonly message: ChatMessage = { messageId: "", source: "CHAT_MESSAGE_SOURCE_SYSTEM", prompt: "" };
@@ -155,7 +159,7 @@ export class ChatAccumulator {
 
   finish(): ChatResult {
     if (!this.hasEnded) throw new Error("No successful EndStream.");
-    if (!["STOP_REASON_STOP_PATTERN", "STOP_REASON_FUNCTION_CALL", "STOP_REASON_MAX_TOKENS"].includes(this.stopReason)) {
+    if (!COMPLETE_STOP_REASONS.has(this.stopReason) && this.stopReason !== "STOP_REASON_MAX_TOKENS") {
       throw new Error(`stopReason cannot be treated as success: ${this.stopReason || "(none)"}`);
     }
     if (this.calls.size > 0) {
@@ -171,7 +175,8 @@ export class ChatAccumulator {
     if (this.stopReason === "STOP_REASON_FUNCTION_CALL" && !this.calls.size) {
       throw new Error("The response ended with FUNCTION_CALL but has no tool call.");
     }
-    if (this.calls.size && this.stopReason !== "STOP_REASON_FUNCTION_CALL") {
+    // Tool use is read from the calls themselves; only calls cut off at the output limit are rejected.
+    if (this.calls.size && !COMPLETE_STOP_REASONS.has(this.stopReason)) {
       throw new Error("Tool calls and the stop reason do not match.");
     }
     this.message.messageId ||= randomUUID();

package/src/pi/messages.ts

@@ -40,14 +40,38 @@ export function attachReplayMetadata(output: AssistantMessage, message: ChatMess
   }
 }
 
+const SCHEMA_MAPS = new Set(["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]);
+const SCHEMA_DATA = new Set(["enum", "const", "default", "examples", "example"]);
+
+/** Devin's own tools give every schema a single `type`; its Gemini route rejects a list such as `["integer", "null"]`. */
+function toDevinToolSchema(schema: unknown): unknown {
+  if (Array.isArray(schema)) return schema.map(toDevinToolSchema);
+  if (!schema || typeof schema !== "object") return schema;
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (SCHEMA_DATA.has(key)) result[key] = value;
+    else if (SCHEMA_MAPS.has(key) && value && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, toDevinToolSchema(child)]));
+    } else if (key === "type" && Array.isArray(value)) {
+      // Omitting the field still covers null; several remaining types become one branch each.
+      const types = value.filter((type) => type !== "null");
+      if (types.length === 1) result.type = types[0];
+      else if (types.length > 1 && !("anyOf" in schema)) result.anyOf = types.map((type) => ({ type }));
+      else result.type = value;
+    } else result[key] = toDevinToolSchema(value);
+  }
+  return result;
+}
+
 export function toDevinTranscript(context: TranscriptContext, model: ModelInfo): { messages: ChatMessage[]; tools: ChatTool[]; systemPrompt: string } {
   const declarations = getCurrentTools(context.messages);
   if (declarations.length && !model.supportsToolCalls) throw new Error("This model does not support the current Pi tool declarations.");
   const tools = declarations.map((tool) => {
-    if (tool.constrainedSampling && (tool.constrainedSampling.type === "grammar" || tool.constrainedSampling.strict === "require")) {
+    // Grammar sampling is optional; like Pi's providers without grammar tools, send the JSON schema instead.
+    if (tool.constrainedSampling && tool.constrainedSampling.type === "json_schema" && tool.constrainedSampling.strict === "require") {
       throw new Error(`Devin does not support this tool's forced sampling format: ${tool.name}`);
     }
-    return { name: tool.name, description: tool.description, jsonSchemaString: JSON.stringify(tool.parameters) };
+    return { name: tool.name, description: tool.description, jsonSchemaString: JSON.stringify(toDevinToolSchema(tool.parameters)) };
   });
   const failedCalls = new Set(context.messages.flatMap((message) => message.role === "assistant" && ["error", "aborted"].includes(message.stopReason)
     ? message.content.filter((block) => block.type === "toolCall").map((block) => block.id) : []));

package/src/pi/stream.ts

@@ -107,7 +107,7 @@ export class DevinResponseStream {
     this.closeContent();
     this.hasTerminated = true;
     this.message.rawStopReason = result.stopReason;
-    this.message.stopReason = result.stopReason === "STOP_REASON_FUNCTION_CALL" ? "toolUse" : result.stopReason === "STOP_REASON_MAX_TOKENS" ? "length" : "stop";
+    this.message.stopReason = result.message.toolCalls?.length ? "toolUse" : result.stopReason === "STOP_REASON_MAX_TOKENS" ? "length" : "stop";
     this.stream.push({ type: "done", reason: this.message.stopReason, message: this.message });
     this.stream.end(this.message);
   }