@agent-native/core 0.84.58 → 0.84.60

package/corpus/templates/clips/app/routes/_app.settings._index.tsx

@@ -399,19 +399,23 @@ export default function SettingsIndexRoute() {
   const [transcriptCleanupEnabled, setTranscriptCleanupEnabled] =
     useState(true);
   const [s3Values, setS3Values] = useState<Record<string, string>>({});
+  const [s3Errors, setS3Errors] = useState<Record<string, string>>({});
+  const [clearingS3, setClearingS3] = useState(false);
   const [s3Expanded, setS3Expanded] = useState(false);
   const [apiKeysExpanded, setApiKeysExpanded] = useState(false);
   const [apiKeyValues, setApiKeyValues] = useState<Record<string, string>>({});
   const [apiKeyStatus, setApiKeyStatus] = useState<Record<string, boolean>>({});
+  const [secretLast4, setSecretLast4] = useState<Record<string, string>>({});
   const [apiKeyStatusLoading, setApiKeyStatusLoading] = useState(true);
   const [savingApiKey, setSavingApiKey] = useState<string | null>(null);
 
   const refreshApiKeyStatus = useCallback(async () => {
     setApiKeyStatusLoading(true);
     try {
-      const [envRes, secretsRes] = await Promise.all([
+      const [envRes, secretsRes, adhocRes] = await Promise.all([
         fetch(agentNativePath("/_agent-native/env-status")),
         fetch(agentNativePath("/_agent-native/secrets")),
+        fetch(agentNativePath("/_agent-native/secrets/adhoc")),
       ]);
       const envData = envRes.ok
         ? ((await envRes.json()) as Array<{
@@ -425,12 +429,24 @@ export default function SettingsIndexRoute() {
             status?: string;
           }>)
         : [];
+      const adhocData = adhocRes.ok
+        ? ((await adhocRes.json()) as Array<{
+            name: string;
+            last4?: string;
+          }>)
+        : [];
       const next = Object.fromEntries(
         envData.map((entry) => [entry.key, Boolean(entry.configured)]),
       );
       for (const entry of secretsData) {
         next[entry.key] = entry.status === "set";
       }
+      const nextLast4: Record<string, string> = {};
+      for (const entry of adhocData) {
+        next[entry.name] = true;
+        if (entry.last4) nextLast4[entry.name] = entry.last4;
+      }
+      setSecretLast4(nextLast4);
       setApiKeyStatus(next);
     } catch {
       setApiKeyStatus({});
@@ -477,7 +493,36 @@ export default function SettingsIndexRoute() {
     }
   }
 
+  function validateS3Values(
+    values: Record<string, string>,
+  ): Record<string, string> {
+    const errors: Record<string, string> = {};
+    const urlFields = ["S3_ENDPOINT", "S3_PUBLIC_BASE_URL"];
+    for (const key of urlFields) {
+      const val = (values[key] ?? "").trim();
+      if (!val) continue;
+      try {
+        const parsed = new URL(val);
+        if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+          errors[key] = t("settings.s3UrlInvalid");
+        }
+      } catch {
+        errors[key] = t("settings.s3UrlInvalid");
+      }
+    }
+    const bucket = (values["S3_BUCKET"] ?? "").trim();
+    if (bucket && !/^[a-z0-9][a-z0-9\-.]{1,61}[a-z0-9]$/.test(bucket)) {
+      errors["S3_BUCKET"] = t("settings.s3BucketInvalid");
+    }
+    return errors;
+  }
+
   async function handleSaveS3Storage() {
+    const validationErrors = validateS3Values(s3Values);
+    if (Object.keys(validationErrors).length > 0) {
+      setS3Errors(validationErrors);
+      return;
+    }
     const s3Configured = storageStatus.data?.activeProvider?.id === "s3";
     const missing = s3Configured
       ? []
@@ -499,7 +544,7 @@ export default function SettingsIndexRoute() {
         ...current,
         S3_SECRET_ACCESS_KEY: "",
       }));
-      await storageStatus.refetch();
+      await Promise.all([storageStatus.refetch(), refreshApiKeyStatus()]);
       toast.success(t("settings.storageSaved"));
     } catch (err) {
       toast.error(
@@ -510,6 +555,51 @@ export default function SettingsIndexRoute() {
     }
   }
 
+  async function handleClearAllS3() {
+    setClearingS3(true);
+    try {
+      const results = await Promise.all(
+        S3_STORAGE_FIELDS.filter((field) => apiKeyStatus[field.key]).map(
+          async (field) => {
+            const res = await fetch(
+              agentNativePath(
+                `/_agent-native/secrets/adhoc/${encodeURIComponent(field.key)}`,
+              ),
+              { method: "DELETE" },
+            );
+            if (!res.ok) {
+              const body = (await res.json().catch(() => null)) as {
+                error?: string;
+              } | null;
+              throw new Error(
+                body?.error ?? `Failed to clear ${field.key} (${res.status})`,
+              );
+            }
+            const body = (await res.json().catch(() => null)) as {
+              removed?: boolean;
+            } | null;
+            return { key: field.key, removed: body?.removed !== false };
+          },
+        ),
+      );
+      const failed = results.filter((r) => !r.removed).map((r) => r.key);
+      if (failed.length > 0) {
+        throw new Error(
+          `Could not remove: ${failed.join(", ")}. You may not have permission.`,
+        );
+      }
+      setS3Values({});
+      await Promise.all([refreshApiKeyStatus(), storageStatus.refetch()]);
+      toast.success(t("settings.keyCleared"));
+    } catch (err) {
+      toast.error(
+        err instanceof Error ? err.message : t("settings.saveFailed"),
+      );
+    } finally {
+      setClearingS3(false);
+    }
+  }
+
   async function handleSaveApiKey(key: string) {
     const value = (apiKeyValues[key] ?? "").trim();
     if (!value) {
@@ -785,34 +875,90 @@ export default function SettingsIndexRoute() {
                       <CollapsibleContent>
                         <div className="space-y-4 border-t border-border px-3 py-4">
                           <div className="grid gap-4 sm:grid-cols-2">
-                            {S3_STORAGE_FIELDS.map((field) => (
-                              <div key={field.key} className="space-y-1.5">
-                                <Label htmlFor={field.key}>
-                                  {t(field.labelKey)}
-                                </Label>
-                                <Input
-                                  id={field.key}
-                                  type={
-                                    "secret" in field && field.secret
-                                      ? "password"
-                                      : "text"
-                                  }
-                                  value={s3Values[field.key] ?? ""}
-                                  onChange={(event) =>
-                                    setS3Values((current) => ({
-                                      ...current,
-                                      [field.key]: event.target.value,
-                                    }))
-                                  }
-                                  placeholder={field.placeholder}
-                                  autoComplete="off"
-                                  disabled={savingStorage}
-                                />
-                              </div>
-                            ))}
+                            {S3_STORAGE_FIELDS.map((field) => {
+                              const configured = Boolean(
+                                apiKeyStatus[field.key],
+                              );
+                              const last4 = secretLast4[field.key];
+                              return (
+                                <div key={field.key} className="space-y-1.5">
+                                  <div className="flex items-center justify-between gap-2">
+                                    <Label htmlFor={field.key}>
+                                      {t(field.labelKey)}
+                                    </Label>
+                                    {configured ? (
+                                      <span className="flex items-center gap-1 text-[10px] font-medium text-primary">
+                                        <IconCheck className="h-3 w-3" />
+                                        {last4
+                                          ? `••••${last4}`
+                                          : t("settings.keySet")}
+                                      </span>
+                                    ) : null}
+                                  </div>
+                                  <Input
+                                    id={field.key}
+                                    type={
+                                      "secret" in field && field.secret
+                                        ? "password"
+                                        : "text"
+                                    }
+                                    value={s3Values[field.key] ?? ""}
+                                    onChange={(event) => {
+                                      setS3Values((current) => ({
+                                        ...current,
+                                        [field.key]: event.target.value,
+                                      }));
+                                      if (s3Errors[field.key]) {
+                                        setS3Errors((current) => {
+                                          const next = { ...current };
+                                          delete next[field.key];
+                                          return next;
+                                        });
+                                      }
+                                    }}
+                                    placeholder={
+                                      configured
+                                        ? t("settings.replaceKey")
+                                        : field.placeholder
+                                    }
+                                    autoComplete="off"
+                                    disabled={savingStorage}
+                                    className={
+                                      s3Errors[field.key]
+                                        ? "border-destructive"
+                                        : undefined
+                                    }
+                                  />
+                                  {s3Errors[field.key] ? (
+                                    <p className="text-[11px] text-destructive">
+                                      {s3Errors[field.key]}
+                                    </p>
+                                  ) : null}
+                                </div>
+                              );
+                            })}
                           </div>
 
-                          <div className="flex justify-end">
+                          <div className="flex items-center justify-end gap-2">
+                            {S3_STORAGE_FIELDS.some(
+                              (field) => apiKeyStatus[field.key],
+                            ) ? (
+                              <Button
+                                type="button"
+                                variant="ghost"
+                                size="sm"
+                                onClick={handleClearAllS3}
+                                disabled={clearingS3 || savingStorage}
+                                className="text-muted-foreground hover:text-destructive"
+                              >
+                                {clearingS3 ? (
+                                  <IconLoader2 className="h-4 w-4 animate-spin" />
+                                ) : (
+                                  <IconTrash className="h-4 w-4" />
+                                )}
+                                {t("settings.clearAllS3")}
+                              </Button>
+                            ) : null}
                             <Button
                               onClick={handleSaveS3Storage}
                               disabled={

package/corpus/templates/clips/app/routes/record.tsx

@@ -462,6 +462,16 @@ function uploadTooLargeMessage(size: number, detail?: string): string {
   )}) after automatic compression. Trim or export a shorter copy and upload again.`;
 }
 
+/** Pre-upload size rejection for a picked file — no compression has been
+ * attempted yet, so the message must not imply it has. */
+function fileTooLargeMessage(size: number): string {
+  return `This file is too large to upload (${formatMb(
+    size,
+  )}, limit is ${formatMb(
+    MAX_UPLOAD_BYTES,
+  )}). Trim it or export a shorter copy and try again.`;
+}
+
 function isUploadFailureError(error: string): boolean {
   return (
     isUploadSizeError(error) ||
@@ -471,7 +481,7 @@ function isUploadFailureError(error: string): boolean {
 
 function friendlyRecordingErrorMessage(error: string): string {
   if (isUploadSizeError(error)) {
-    return `This video is too large for Clips after automatic compression. Trim or export a shorter copy under ${formatMb(
+    return `This video is too large for Clips. Trim or export a shorter copy under ${formatMb(
       MAX_UPLOAD_BYTES,
     )} and upload again.`;
   }
@@ -835,6 +845,12 @@ export default function RecordRoute() {
   const [compressionProgress, setCompressionProgress] = useState<number | null>(
     null,
   );
+  // Fraction (0-1) of upload chunks confirmed sent so far. Chunks are fixed-size
+  // slices of the already-recorded blob, so chunksSent / totalChunks is a
+  // truthful proxy for bytes uploaded — not simulated. Null means the total
+  // chunk count isn't known yet (e.g. the brief live-streaming remainder
+  // upload), so the overlay falls back to an indeterminate spinner.
+  const [uploadProgress, setUploadProgress] = useState<number | null>(null);
 
   const queryClient = useQueryClient();
   const { isDesktopApp } = useDesktopPromo();
@@ -1103,19 +1119,29 @@ export default function RecordRoute() {
               // upload — applies whether or not we just came from
               // compressing.
               setCompressionProgress(null);
+              // Reset upload progress at the start of each upload attempt so
+              // a retry doesn't briefly show the previous attempt's percent.
+              setUploadProgress(null);
               // Always sync the UI back to "uploading"; if we were already
               // there from doStop's pre-stop transition, this is a no-op.
               setUiState("uploading");
             }
           },
-          onChunk: ({ index, bytes }) => {
+          onChunk: ({ index, total }) => {
+            // `total` is only known once the full recording is sliced into
+            // fixed-size chunks after stop(); the live per-chunk uploads
+            // during recording report `total: null` and don't drive this bar.
+            const fraction = total ? (index + 1) / total : null;
+            setUploadProgress(fraction);
             const recordingId = pendingRef.current?.id;
             if (!recordingId) return;
+            // Only expose a percentage here — this state is agent-visible, and
+            // chunk/byte counts are an internal transport detail, not
+            // something to surface to the user.
             void writeAppState(`recording-upload-${recordingId}`, {
               recordingId,
               status: "uploading",
-              chunksReceived: index + 1,
-              lastChunkBytes: bytes,
+              progress: fraction !== null ? Math.round(fraction * 100) : null,
               updatedAt: new Date().toISOString(),
             }).catch(() => {});
           },
@@ -1378,6 +1404,7 @@ export default function RecordRoute() {
       setError(null);
       setUiState("uploading");
       setCompressionProgress(null);
+      setUploadProgress(null);
 
       const acceptedMime = new Set([
         "video/mp4",
@@ -1406,6 +1433,22 @@ export default function RecordRoute() {
         return;
       }
 
+      // Fail fast on oversized files before we probe metadata, attempt
+      // compression, or open the upload session — no point spending time or
+      // chunking bytes for a file the server will reject anyway. Uses the
+      // same MAX_UPLOAD_BYTES ceiling as the (currently compression-gated)
+      // post-compression check below and the server chunk/finalize routes.
+      if (file.size > MAX_UPLOAD_BYTES) {
+        const message = fileTooLargeMessage(file.size);
+        if (fileUploadAbortRef.current === abort) {
+          fileUploadAbortRef.current = null;
+        }
+        setError(message);
+        setUiState("error");
+        toast.error(message);
+        return;
+      }
+
       let createdId: string | null = null;
       try {
         const status = await fetchVideoStorageStatus();
@@ -1628,6 +1671,7 @@ export default function RecordRoute() {
                 unknown
               > | null) ?? null;
           }
+          setUploadProgress((i + 1) / totalChunks);
         }
 
         setUiState("complete");
@@ -1699,6 +1743,7 @@ export default function RecordRoute() {
           fileUploadAbortRef.current = null;
         }
         setCompressionProgress(null);
+        setUploadProgress(null);
       }
     },
     [markStorageConfigured, navigate, probeVideoMetadata],
@@ -1863,6 +1908,7 @@ export default function RecordRoute() {
       setCameraStream(null);
       setPreviewStream(null);
       setCompressionProgress(null);
+      setUploadProgress(null);
       setUiState("complete");
       if (result.waitingForStorage) {
         toast.info(t("recordRoute.recordingReadyToUpload"), {
@@ -2006,6 +2052,7 @@ export default function RecordRoute() {
 
     setError(null);
     setCompressionProgress(null);
+    setUploadProgress(null);
     setUiState("uploading");
     try {
       const retryResult = await engine.retryUpload();
@@ -2022,6 +2069,7 @@ export default function RecordRoute() {
         body: JSON.stringify({ reason: message }),
       }).catch(() => {});
       setCompressionProgress(null);
+      setUploadProgress(null);
       setError(message);
       setUiState("error");
       toast.error(t("recordRoute.uploadFailed"), {
@@ -2085,6 +2133,7 @@ export default function RecordRoute() {
     setPreviewStream(null);
     setIsPaused(false);
     setUiState("idle");
+    setUploadProgress(null);
     pendingRef.current = null;
     engineRef.current = null;
   }, [extensionCapture, liveTranscription]);
@@ -2427,7 +2476,9 @@ export default function RecordRoute() {
           users wonder if the app froze). */}
       {(uiState === "uploading" || uiState === "compressing") && (
         <div className="fixed inset-0 z-[120] flex flex-col items-center justify-center gap-3 bg-black/70 text-white backdrop-blur">
-          <Spinner className="h-10 w-10 text-white/70" />
+          {!(uiState === "uploading" && uploadProgress !== null) && (
+            <Spinner className="h-10 w-10 text-white/70" />
+          )}
           {uiState === "compressing" ? (
             <>
               <div className="text-sm">
@@ -2441,7 +2492,24 @@ export default function RecordRoute() {
               </div>
             </>
           ) : (
-            <div className="text-sm">{t("recordRoute.savingRecording")}</div>
+            <>
+              <div className="text-sm">{t("recordRoute.savingRecording")}</div>
+              {uploadProgress !== null && (
+                <div className="flex w-48 flex-col items-center gap-1">
+                  <div className="h-1.5 w-full overflow-hidden rounded-full bg-white/20">
+                    <div
+                      className="h-full rounded-full bg-white transition-all"
+                      style={{
+                        width: `${Math.min(100, Math.max(0, Math.round(uploadProgress * 100)))}%`,
+                      }}
+                    />
+                  </div>
+                  <div className="text-[11px] text-white/50">
+                    {Math.round(uploadProgress * 100)}%
+                  </div>
+                </div>
+              )}
+            </>
           )}
           <button
             onClick={doCancel}

package/dist/action.js

@@ -210,6 +210,80 @@ function wrapRunWithAudit(run, auditConfig) {
 // ---------------------------------------------------------------------------
 // Schema → JSON Schema conversion
 // ---------------------------------------------------------------------------
+// Keywords whose value is a single subschema.
+const SUBSCHEMA_VALUE_KEYS = [
+    "items",
+    "additionalItems",
+    "contains",
+    "additionalProperties",
+    "not",
+    "if",
+    "then",
+    "else",
+];
+// Keywords whose value is an array of subschemas.
+const SUBSCHEMA_ARRAY_KEYS = [
+    "allOf",
+    "anyOf",
+    "oneOf",
+    "prefixItems",
+];
+// Keywords whose value is a map of name → subschema.
+const SUBSCHEMA_MAP_KEYS = [
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+    "dependentSchemas",
+];
+/**
+ * Remove JSON Schema keywords that some providers' function-calling schema
+ * validators reject. OpenAI (and Gemini via the Builder gateway) reject
+ * `propertyNames` — which Zod v4 emits for `z.record(z.string(), …)` — with a
+ * `400 invalid_function_parameters` error, causing the model turn to produce no
+ * content (surfacing as an empty assistant response). Anthropic ignores the
+ * keyword, so stripping it is safe across providers and keeps action schemas
+ * portable. `propertyNames` only constrained object *keys*; the value/shape of
+ * the object is unaffected by its removal.
+ *
+ * Only descends through actual subschema positions (properties, items, union
+ * branches, definitions, etc.) — never through value-bearing keywords like
+ * `default`, `const`, `enum`, or `examples`, whose objects may legitimately
+ * contain a `propertyNames` data key that must be preserved.
+ */
+function stripUnsupportedSchemaKeywords(node) {
+    if (!node || typeof node !== "object" || Array.isArray(node))
+        return node;
+    const obj = node;
+    delete obj.propertyNames;
+    for (const key of SUBSCHEMA_VALUE_KEYS) {
+        // `items`/`additionalItems` may also be an array of subschemas.
+        const value = obj[key];
+        if (Array.isArray(value)) {
+            for (const sub of value)
+                stripUnsupportedSchemaKeywords(sub);
+        }
+        else {
+            stripUnsupportedSchemaKeywords(value);
+        }
+    }
+    for (const key of SUBSCHEMA_ARRAY_KEYS) {
+        const value = obj[key];
+        if (Array.isArray(value)) {
+            for (const sub of value)
+                stripUnsupportedSchemaKeywords(sub);
+        }
+    }
+    for (const key of SUBSCHEMA_MAP_KEYS) {
+        const value = obj[key];
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            for (const sub of Object.values(value)) {
+                stripUnsupportedSchemaKeywords(sub);
+            }
+        }
+    }
+    return node;
+}
 /**
  * Convert a Standard Schema to JSON Schema for the Claude API.
  * Tries vendor-specific toJSONSchema first (Zod v4), then falls back
@@ -229,7 +303,7 @@ function schemaToJsonSchema(schema, _description) {
             if (result && typeof result === "object") {
                 delete result.$schema;
             }
-            return result;
+            return stripUnsupportedSchemaKeywords(result);
         }
         catch {
             // Fall through to manual converter
@@ -237,7 +311,7 @@ function schemaToJsonSchema(schema, _description) {
     }
     // Fallback: manual conversion from Zod v4 internal defs
     if (s._zod?.def) {
-        return zodDefToJsonSchema(s._zod.def);
+        return stripUnsupportedSchemaKeywords(zodDefToJsonSchema(s._zod.def));
     }
     // Last resort: empty object schema
     return { type: "object", properties: {} };