@steve31415/baselib 3.29.0 → 3.31.0

package/README.md

@@ -29,7 +29,9 @@ ERROR log (`~/plasticine-way/docs/SECURITY.md`, "Resend API key").
 
 Bins: `check-test-owners` — the fleet's structural test-coverage gate; every
 app runs it from `npm run verify`. `pw-deploy` / `pw-rollback` — the fleet
-deploy (`~/plasticine-way/docs/OPERATIONS.md`, "Deployment safety").
+deploy (`~/plasticine-way/docs/OPERATIONS.md`, "Deployment safety"); an
+app's hooks module (`DeployHooks` in `src/deploy/types.ts`) extends both,
+`postRollback` being the one hook `pw-rollback` runs.
 `pw-sql` / `pw-logs` — read-only production queries (database, Axiom), the
 first step of any production investigation (same doc, "Investigating
 production state").

package/dist/deploy/rollback.js

@@ -7,7 +7,7 @@ import { hostname } from 'node:os';
 import { must, mustJson } from './exec.js';
 import { openEvidence, PhaseTimer } from './evidence.js';
 import { acquireLock, listReleaseRecords, placeHold, releaseLock } from './gcs.js';
-import { DEFAULT_ACCOUNT, loadConfig } from './config.js';
+import { DEFAULT_ACCOUNT, loadConfig, loadHooks } from './config.js';
 import { pickRevisionForSha, releaseEntriesFrom, selectRollbackTarget, readServingState, SHA40, } from './plan.js';
 export async function runRollback(options) {
     const log = options.log ?? ((m) => console.error(`[pw-rollback] ${m}`));
@@ -19,6 +19,7 @@ export async function runRollback(options) {
     const requested = argv.find((a) => SHA40.test(a));
     const timer = new PhaseTimer(log);
     let evidenceDir = '';
+    let rolledBackTo = '';
     let lock = null;
     try {
         const config = await loadConfig(options.repoRoot);
@@ -151,6 +152,26 @@ export async function runRollback(options) {
                 throw new Error(`${service.name}: post-rollback smoke failed (${lastDetail})`);
             log(`${service.name}: smoke passed`);
         }
+        // The hooks module is loaded only now: a broken one must not stand
+        // between an incident and the traffic move.
+        timer.enter('hooks');
+        rolledBackTo = target;
+        const hooks = await loadHooks(options.repoRoot, config);
+        if (hooks.postRollback) {
+            const ctx = {
+                sha: target,
+                baseSha: servingShas.length === 1 ? servingShas[0] : null,
+                config,
+                repoRoot: options.repoRoot,
+                contextDir: '',
+                evidenceDir,
+                imageDigest: targets[0].imageDigest,
+                serving,
+                exec: runner,
+                log,
+            };
+            await hooks.postRollback(ctx);
+        }
         timer.close();
         log(`rolled back to ${target.slice(0, 12)}`);
         log(`hold placed on ${servingShas.map((sha) => sha.slice(0, 12)).join(', ')} — ` +
@@ -162,6 +183,10 @@ export async function runRollback(options) {
         const message = error instanceof Error ? error.message : String(error);
         console.error(message);
         console.error(`rollback failed in phase: ${timer.current}`);
+        if (rolledBackTo) {
+            console.error(`traffic IS on ${rolledBackTo.slice(0, 12)} and the hold is placed; only the app's ` +
+                'postRollback hook failed — finish what it does by hand');
+        }
         if (evidenceDir)
             console.error(`evidence: ${evidenceDir}`);
         return 1;

package/dist/deploy/types.d.ts

@@ -120,4 +120,11 @@ export interface DeployHooks {
     smoke?: (ctx: HookContext) => Promise<void>;
     /** Runs after everything else succeeded (e.g. notes's release state). */
     postSuccess?: (ctx: HookContext) => Promise<void>;
+    /** pw-rollback only: runs after traffic is back on the target build, the
+     *  hold is placed and the smoke passed — for what a traffic move does not
+     *  carry (e.g. podcasts' render Job image). `sha` and `imageDigest` are the
+     *  rollback target's, `serving` is the state rolled back from, and
+     *  `contextDir` is empty (nothing is built). A throw fails the command but
+     *  undoes nothing. */
+    postRollback?: (ctx: HookContext) => Promise<void>;
 }

package/dist/llm/providers/anthropic.js

@@ -13,32 +13,35 @@ function classifyFinish(stopReason) {
     }
 }
 /**
- * Keywords `output_config.format` rejects outright with a 400 (verified on
- * Opus 5.5, 2026-09-22). `minItems` is also rejected for values other than 0
- * or 1, handled separately; `minLength`/`maxLength`, `pattern` and `format`
- * are accepted.
+ * Keywords Anthropic's constrained decoding rejects outright with a 400 —
+ * `output_config.format` (verified on Opus 5.5, 2026-09-22) and strict tools
+ * alike (verified on every forced-tool registry model, 2026-10-07). `minItems`
+ * is also rejected for values other than 0 or 1, handled separately;
+ * `minLength`/`maxLength`, `pattern`, `format` and nullable unions are
+ * accepted.
  */
-const UNSUPPORTED_FORMAT_KEYWORDS = [
+const UNSUPPORTED_STRICT_KEYWORDS = [
     'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf',
     'maxItems', 'uniqueItems',
 ];
 /**
- * Transform a portable JSON schema into the dialect Anthropic's structured
- * outputs (`output_config.format`) accepts: every object schema must set
- * `additionalProperties: false`, and the numeric/array bounds listed above are
- * dropped. The model then no longer enforces those bounds — callers validate
- * the parsed result as they already must for truncation. Unlike forced
- * tool_use, optional properties stay optional. Returns a deep copy — the
- * caller's schema object is reused across failover attempts.
+ * Transform a portable JSON schema into the dialect Anthropic's constrained
+ * decoding accepts (`output_config.format` and `strict: true` tools): every
+ * object schema must set `additionalProperties: false`, and the numeric/array
+ * bounds listed above are dropped. The model then no longer enforces those
+ * bounds — callers validate the parsed result as they already must for
+ * truncation. Optional properties stay optional (unlike OpenAI's strict
+ * dialect). Returns a deep copy — the caller's schema object is reused across
+ * failover attempts.
  */
-function toOutputFormatSchema(node) {
+function toAnthropicStrictSchema(node) {
     if (Array.isArray(node))
-        return node.map(toOutputFormatSchema);
+        return node.map(toAnthropicStrictSchema);
     if (node === null || typeof node !== 'object')
         return node;
     const out = {};
     for (const [key, value] of Object.entries(node)) {
-        if (UNSUPPORTED_FORMAT_KEYWORDS.includes(key))
+        if (UNSUPPORTED_STRICT_KEYWORDS.includes(key))
             continue;
         if (key === 'minItems' && typeof value === 'number' && value > 1)
             continue;
@@ -46,10 +49,10 @@ function toOutputFormatSchema(node) {
         // property that happens to be named `minimum` is kept.
         if ((key === 'properties' || key === '$defs' || key === 'definitions')
             && value !== null && typeof value === 'object' && !Array.isArray(value)) {
-            out[key] = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, toOutputFormatSchema(v)]));
+            out[key] = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, toAnthropicStrictSchema(v)]));
             continue;
         }
-        out[key] = toOutputFormatSchema(value);
+        out[key] = toAnthropicStrictSchema(value);
     }
     const type = out.type;
     if (type === 'object' || (Array.isArray(type) && type.includes('object'))) {
@@ -87,20 +90,25 @@ export const anthropicProvider = {
                 ? [{ type: 'text', text: request.systemPrompt, cache_control: { type: 'ephemeral' } }]
                 : request.systemPrompt;
         }
-        // JSON schema: a forced tool_use call where the model allows it, else
-        // structured outputs (Opus 5.5 rejects forced tool_choice).
+        // JSON schema: a forced, strict tool_use call where the model allows it,
+        // else structured outputs (Opus 5.5 rejects forced tool_choice). Both
+        // constrain decoding to the schema. A tool without `strict: true` is not
+        // enforced: Sonnet 5 returned an array property as a JSON string (digest,
+        // 2026-10-06), Opus 4.8 one wrapped in leaked tool-call markup (podcasts,
+        // 2026-09-15).
         const useOutputFormat = request.jsonSchema !== undefined && !request.supportsForcedToolChoice;
         if (request.jsonSchema && useOutputFormat) {
             body.output_config = {
                 ...body.output_config,
-                format: { type: 'json_schema', schema: toOutputFormatSchema(request.jsonSchema.schema) },
+                format: { type: 'json_schema', schema: toAnthropicStrictSchema(request.jsonSchema.schema) },
             };
         }
         else if (request.jsonSchema) {
             body.tools = [{
                     name: request.jsonSchema.name,
                     description: `Generate structured output matching the ${request.jsonSchema.name} schema`,
-                    input_schema: request.jsonSchema.schema,
+                    input_schema: toAnthropicStrictSchema(request.jsonSchema.schema),
+                    strict: true,
                 }];
             body.tool_choice = { type: 'tool', name: request.jsonSchema.name };
         }

package/dist/llm/providers/openai.js

@@ -37,10 +37,10 @@ function makeNullable(propSchema) {
  * Transform a portable JSON schema into the shape OpenAI's strict Structured
  * Outputs mode requires: every object must set `additionalProperties: false`
  * and list ALL of its properties in `required`. Callers author one portable
- * schema (which also works on Anthropic's tool_use and Gemini's responseSchema,
- * both of which tolerate missing `additionalProperties` and optional fields);
- * this keeps the OpenAI-specific dialect local to this adapter, mirroring the
- * Gemini adapter's own `stripUnsupportedSchemaFields`. Returns a deep copy — the
+ * schema; this keeps the OpenAI-specific dialect local to this adapter,
+ * mirroring the Gemini adapter's `stripUnsupportedSchemaFields` and the
+ * Anthropic adapter's `toAnthropicStrictSchema` (which closes objects but keeps
+ * optional fields optional). Returns a deep copy — the
  * caller's schema object is never mutated (it is reused across failover attempts).
  */
 function toStrictSchema(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.29.0",
+  "version": "3.31.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",