@agent-native/core 0.227.0-nightly-20261110182415 → 0.227.0

package/dist/agent/default-agent-engine.d.ts

@@ -51,6 +51,7 @@ export interface DefaultAgentEngineSelection {
     engine: string;
     model: string;
 }
+export declare function isDefaultAgentEngineScopeResolved(ctx?: DefaultAgentEngineContext): boolean;
 /**
  * Read the default that applies to `ctx` (the current request when omitted):
  * the organization's row, else an explicitly personal user's own row, else

package/dist/agent/default-agent-engine.js

@@ -36,6 +36,11 @@ function normalizedContext(ctx) {
 function hasEngine(value) {
     return typeof value.engine === "string" && value.engine.trim().length > 0;
 }
+export function isDefaultAgentEngineScopeResolved(ctx = requestContext()) {
+    return !!(normalizedContext(ctx).orgId ||
+        ctx.orgScope === "personal" ||
+        ctx.defaultAgentEngineScope === "deployment");
+}
 /**
  * Read the default that applies to `ctx` (the current request when omitted):
  * the organization's row, else an explicitly personal user's own row, else
@@ -47,9 +52,7 @@ function hasEngine(value) {
  */
 export async function readDefaultAgentEngineSettingDetailed(ctx = requestContext()) {
     const { userEmail, orgId } = normalizedContext(ctx);
-    if (!orgId &&
-        ctx.orgScope !== "personal" &&
-        ctx.defaultAgentEngineScope !== "deployment") {
+    if (!isDefaultAgentEngineScopeResolved(ctx)) {
         throw new Error("Organization scope could not be resolved.");
     }
     if (orgId) {

package/dist/agent/engine/builder-engine.js

@@ -803,22 +803,26 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                         const errMsg = event.error ||
                             event.message ||
                             "Builder gateway rejected the request as malformed.";
-                        const rawErrCode = typeof event.errorCode === "string"
+                        const gatewayErrCode = typeof event.errorCode === "string"
                             ? event.errorCode
                             : typeof event.code === "string"
                                 ? event.code
-                                : "invalid_request";
-                        const errCode = canonicalizeBuilderGatewayErrorCode(rawErrCode, String(errMsg)) ??
-                            rawErrCode;
+                                : undefined;
+                        const errCode = canonicalizeBuilderGatewayErrorCode(gatewayErrCode, String(errMsg)) ??
+                            gatewayErrCode ??
+                            "invalid_request";
                         const gatewayRequestId = typeof event.requestId === "string" ? event.requestId : undefined;
-                        console.warn(`[builder-engine] stop reason=invalid_request model=${model} code=${errCode} requestId=${gatewayRequestId ?? "(none)"} providerMessagePresent=${Boolean(event.error || event.message || event.detail)}`);
+                        console.warn(`[builder-engine] stop reason=invalid_request model=${model} code=${errCode} requestId=${gatewayRequestId ?? "(none)"} requestShape=${JSON.stringify(captureContext.requestShape)} providerMessagePresent=${Boolean(event.error || event.message || event.detail)}`);
                         if (isExplicitBuilderCreditsLimitCode(errCode)) {
                             await notifyBuilderCreditLimit();
                         }
                         yield stop({
                             error: errMsg,
                             errorCode: errCode,
-                            providerRetryable: errCode === BUILDER_GATEWAY_INTERNAL_ERROR_CODE,
+                            // Without a gateway code the masked envelope does not say the fault
+                            // was transient, and the rejected request would be sent unchanged.
+                            providerRetryable: gatewayErrCode !== undefined &&
+                                errCode === BUILDER_GATEWAY_INTERNAL_ERROR_CODE,
                             ...(isCreditsLimitErrorCode(errCode)
                                 ? { upgradeUrl: await buildUpgradeUrl() }
                                 : {}),

package/dist/agent/engine/chat-model-availability.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether the current request's user can run a chat model: Builder, a provider
+ * key of their own, or a deployment key. A connected Builder account counts
+ * even when its credits are spent: that is a top-up problem, not a missing
+ * model. "unknown" means the engine or its credential could not be resolved,
+ * which is not the same as having none.
+ */
+export type ChatModelAvailability = "available" | "unavailable" | "unknown";
+export declare function resolveChatModelAvailability(): Promise<ChatModelAvailability>;

package/dist/agent/engine/chat-model-availability.js

@@ -0,0 +1,39 @@
+import { getAppConfig } from "../../app-config/index.js";
+import { readDeployCredentialEnv } from "../../server/credential-provider.js";
+import { getRequestOrgId, getRequestUserEmail, } from "../../server/request-context.js";
+import { resolveChatEngine, resolveOwnerEngineApiKey, } from "../production-agent.js";
+import { isResolvedEngineUsableForRequest, registerBuiltinEngines, } from "./index.js";
+export async function resolveChatModelAvailability() {
+    // Credentials and the default-engine setting are both read in the request's
+    // scope, so only the request user can be checked; with none, there is no one
+    // whose model to look up, which is "unknown", never "unavailable".
+    const userEmail = getRequestUserEmail();
+    if (!userEmail)
+        return "unknown";
+    const orgId = getRequestOrgId() ?? null;
+    try {
+        registerBuiltinEngines();
+        const credentialIdentity = { userEmail, orgId };
+        const anthropicFallback = readDeployCredentialEnv("ANTHROPIC_API_KEY");
+        const ownerKey = await resolveOwnerEngineApiKey({
+            ownerEmail: userEmail,
+            ...(anthropicFallback ? { anthropicFallback } : {}),
+        });
+        const appId = getAppConfig().app.id ?? getAppConfig().app.template;
+        const engine = await resolveChatEngine({
+            ownerKey,
+            ...(appId ? { appId } : {}),
+            credentialIdentity,
+        });
+        return (await isResolvedEngineUsableForRequest(engine, {
+            ...(ownerKey.apiKey ? { apiKey: ownerKey.apiKey } : {}),
+            credentialIdentity,
+        }))
+            ? "available"
+            : "unavailable";
+    }
+    catch (error) {
+        console.warn("[chat-model-availability] could not resolve the chat engine:", error instanceof Error ? error.message : error);
+        return "unknown";
+    }
+}

package/dist/agent/optional-placeholders.d.ts

@@ -10,6 +10,7 @@ export declare function schemaAcceptsToolValue(schema: object, value: unknown):
 export declare function discriminatedBranchIndex(branches: readonly AgentNativeJsonSchema[], value: unknown): number;
 export declare class AmbiguousToolPlaceholdersError extends Error {
     readonly errorCode = "ambiguous_tool_placeholders";
+    readonly statusCode = 400;
     constructor();
 }
 export declare function normalizeOptionalToolPlaceholders(schema: RawJsonSchema | undefined, input: unknown, entry: Parameters<typeof actionCallReadOnly>[0] & {

package/dist/agent/optional-placeholders.js

@@ -167,6 +167,9 @@ function stripOptionalToolPlaceholders(schema, value, emptyValues, depth = 0) {
 }
 export class AmbiguousToolPlaceholdersError extends Error {
     errorCode = "ambiguous_tool_placeholders";
+    // A refusal of the caller's input that ran nothing, so the HTTP action
+    // route answers 400 with this message rather than a captured 500.
+    statusCode = 400;
     constructor() {
         super("Tool input mixes invalid placeholders with valid empty values, so it is unclear which fields should be cleared. " +
             "No action was run. Retry the native tool with sparse JSON containing only the intended changes. " +

package/dist/cli/index.js

@@ -1098,7 +1098,7 @@ Options:
   --eager                       With workspace dev, start every app immediately
   --prewarm                     With workspace dev, warm non-default apps in the background
   --no-prewarm                  With workspace dev, keep non-default apps lazy
-  --no-open                     With workspace dev, do not open a browser
+  --no-open                     With dev or workspace dev, do not open a browser
   --url <url>                   URL to audit with audit-agent-web
 
 Feedback:  ${FEEDBACK_URL}