@code-yeongyu/senpi-ai 2026.10.13 → 2026.10.15

package/dist/providers/opencode-go.d.ts

@@ -1,3 +1,5 @@
 import { type Provider } from "../models.ts";
-export declare function opencodeGoProvider(): Provider<"anthropic-messages" | "openai-completions" | "openai-responses">;
+type OpenCodeGoApi = "anthropic-messages" | "google-generative-ai" | "openai-completions" | "openai-responses";
+export declare function opencodeGoProvider(): Provider<OpenCodeGoApi>;
+export {};
 //# sourceMappingURL=opencode-go.d.ts.map

package/dist/providers/opencode-go.js

@@ -1,4 +1,5 @@
 import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.js";
+import { googleGenerativeAIApi } from "../api/google-generative-ai.lazy.js";
 import { openAICompletionsApi } from "../api/openai-completions.lazy.js";
 import { openAIResponsesApi } from "../api/openai-responses.lazy.js";
 import { envApiKeyAuth } from "../auth/helpers.js";
@@ -13,6 +14,7 @@ export function opencodeGoProvider() {
         models: Object.values(OPENCODE_GO_MODELS),
         api: {
             "anthropic-messages": withOpenCodeSessionHeader(anthropicMessagesApi()),
+            "google-generative-ai": withOpenCodeSessionHeader(googleGenerativeAIApi()),
             "openai-completions": withOpenCodeSessionHeader(openAICompletionsApi()),
             "openai-responses": withOpenCodeSessionHeader(openAIResponsesApi()),
         },

package/dist/utils/provider-failure-description.js

@@ -1,4 +1,17 @@
-import { describeProviderStallForUser, formatStallDuration } from "./retry.js";
+import { describeProviderStallForUser, formatStallDuration, isAnthropicThirdPartyBillingMessage, } from "./retry.js";
+const CLAUDE_EXTRA_USAGE_URL = "https://claude.ai/settings/usage";
+/**
+ * senpi#3259: the billing path is the whole story. On the direct `anthropic` provider a Claude
+ * subscription token is billed as a third-party app, so the fix is the Agent SDK lane; on the
+ * `anthropic-subscription` lane the request already ran through Claude Code, so only extra usage or
+ * another model can help.
+ */
+function describeAnthropicThirdPartyBilling(provider) {
+    if (provider === "anthropic-subscription") {
+        return `Anthropic billed this Claude Code request to your extra usage instead of your plan limits, and your extra usage is used up. Add extra usage at ${CLAUDE_EXTRA_USAGE_URL}, or switch to another model with /model.`;
+    }
+    return `Anthropic billed this request to your extra usage instead of your Claude plan limits, because a Claude subscription used directly through the Anthropic API counts as a third-party app. Run /login and choose "Anthropic Subscription (Claude Pro/Max)" so requests run through Claude Code and use your plan limits, add extra usage at ${CLAUDE_EXTRA_USAGE_URL}, or switch to another model with /model.`;
+}
 /**
  * Session-internal replay-suppression signal, read off the error text by the
  * retry predicates. A failover lane stamps it when replaying the turn could
@@ -44,6 +57,9 @@ export function describeProviderFailureForUser(errorMessage, options = {}) {
     const message = stripTurnRetrySuppressionPrefix(errorMessage).trim();
     if (!message)
         return undefined;
+    if (isAnthropicThirdPartyBillingMessage(message)) {
+        return describeAnthropicThirdPartyBilling(options.model?.split("/")[0]);
+    }
     if (options.usageLimit === "account") {
         const provider = options.model?.split("/")[0];
         const reset = /\bresets?\s+([^"}\n]+)/i

package/dist/utils/retry.d.ts

@@ -24,6 +24,14 @@ export declare const USAGE_LIMIT_EXHAUSTION: {
     /** Message markers: the codes appear verbatim in bodies, plus the sentence. */
     readonly markers: readonly ["usage_limit_reached", "usage_not_included", "usage limit has been reached"];
 };
+/**
+ * Anthropic's rejection of a Claude subscription token used outside Claude Code (senpi#3259): a
+ * 400 invalid_request_error reading "Third-party apps now draw from your extra usage, not your plan
+ * limits. Add more at claude.ai/settings/usage and keep going." The request was billed to extra
+ * usage instead of the plan, so every model on the same credential is refused the same way.
+ */
+export declare const ANTHROPIC_THIRD_PARTY_BILLING_MARKER = "Third-party apps now draw from your extra usage";
+export declare function isAnthropicThirdPartyBillingMessage(errorMessage: string | undefined): boolean;
 export declare function isQuotaExhaustionMessage(errorMessage: string | undefined): boolean;
 /**
  * Retry policy: bounded attempts with exponential backoff (`baseDelayMs * 2^(attempt-1)`).

package/dist/utils/retry.js

@@ -38,6 +38,16 @@ export const USAGE_LIMIT_EXHAUSTION = {
     /** Message markers: the codes appear verbatim in bodies, plus the sentence. */
     markers: ["usage_limit_reached", "usage_not_included", "usage limit has been reached"],
 };
+/**
+ * Anthropic's rejection of a Claude subscription token used outside Claude Code (senpi#3259): a
+ * 400 invalid_request_error reading "Third-party apps now draw from your extra usage, not your plan
+ * limits. Add more at claude.ai/settings/usage and keep going." The request was billed to extra
+ * usage instead of the plan, so every model on the same credential is refused the same way.
+ */
+export const ANTHROPIC_THIRD_PARTY_BILLING_MARKER = "Third-party apps now draw from your extra usage";
+export function isAnthropicThirdPartyBillingMessage(errorMessage) {
+    return errorMessage?.toLowerCase().includes(ANTHROPIC_THIRD_PARTY_BILLING_MARKER.toLowerCase()) === true;
+}
 /**
  * Account quota, budget, credit, and billing exhaustion: the account cannot
  * serve more requests until the user pays or the quota resets. Shared by the
@@ -70,6 +80,8 @@ const QUOTA_EXHAUSTION_PATTERNS = [
     // stays dead until its quota resets — every same-account retry is guaranteed
     // to fail, so the failure is terminal, not rate-limited.
     ...USAGE_LIMIT_EXHAUSTION.markers,
+    // Anthropic billing a subscription token as a third-party app (senpi#3259).
+    escapeRegExp(ANTHROPIC_THIRD_PARTY_BILLING_MARKER),
 ];
 const QUOTA_EXHAUSTION_PATTERN = buildProviderErrorPattern(QUOTA_EXHAUSTION_PATTERNS);
 export function isQuotaExhaustionMessage(errorMessage) {

package/dist/utils/tool-schema-compat.js

@@ -202,12 +202,17 @@ export function normalizeToolParametersForOpenAICompat(schema) {
 /**
  * Guarantee the wire shape every OpenAI-compatible backend requires for tool
  * parameters: a root object schema. A root union of object shapes is merged into
- * one object schema; a root that merely lost its `type` gets it restored.
+ * one object schema and a root that already declares a `type` is returned as-is.
+ * Every other root without a `type` gets `type: "object"`: a `$ref` root, a root
+ * `allOf`, and an `anyOf`/`oneOf` union that cannot merge because a branch is not
+ * an object shape. Any combiner is kept beside the added type.
  *
- * A root whose branches are not object shapes is left alone: forcing
- * `type: "object"` onto a scalar union would assert something the schema
- * contradicts, which is worse than the missing keyword. Tool parameters are
- * objects in practice, so this only guards against corrupting an exotic schema.
+ * DeepSeek and gateways forwarding to it reject a typeless root outright
+ * (`schema must be a JSON Schema of 'type: "object"', got 'type: null'`, #3245).
+ * The cost: for a union with no object branch the wire schema becomes stricter
+ * than the source (`type: "object"` beside `anyOf: [string, number]` is
+ * unsatisfiable). That is accepted because tool arguments are always JSON objects
+ * and are validated locally against the original, unnormalized schema.
  */
 function ensureRootObjectSchema(schema) {
     const merged = mergeRootObjectUnion(schema);
@@ -215,11 +220,6 @@ function ensureRootObjectSchema(schema) {
         return merged;
     if (schema.type !== undefined)
         return schema;
-    // DeepSeek (and gateways forwarding to it) reject any root parameters schema
-    // without `type: "object"` (`got 'type: null'`). When the root union cannot
-    // merge, keep the combiner and claim the object type rather than send a
-    // typeless root: tool parameters are objects in practice, and the wire
-    // shape stays valid for validators that enforce the root type.
     return { ...schema, type: "object" };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-ai",
-	"version": "2026.10.13",
+	"version": "2026.10.15",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -88,7 +88,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "0.127.0",
 		"@aws-sdk/client-bedrock-runtime": "3.1136.0",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.13",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.15",
 		"@google/genai": "2.23.0",
 		"@smithy/node-http-handler": "4.12.1",
 		"http-proxy-agent": "9.1.0",