salesforce-data-customcode 6.1.0.dev7__tar.gz → 7.0.0rc1__tar.gz

{salesforce_data_customcode-6.1.0.dev7 → salesforce_data_customcode-7.0.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salesforce-data-customcode
-Version: 6.1.0.dev7
+Version: 7.0.0rc1
 Summary: Data Cloud Custom Code SDK
 License-Expression: Apache-2.0
 License-File: LICENSE.txt

{salesforce_data_customcode-6.1.0.dev7 → salesforce_data_customcode-7.0.0rc1}/pyproject.toml

@@ -18,7 +18,7 @@ license = "Apache-2.0"
 name = "salesforce-data-customcode"
 readme = "README.md"
 requires-python = ">=3.10,<3.12"
-version = "6.1.0.dev7"
+version = "7.0.0rc1"
 
 [tool.black]
 exclude = '''

{salesforce_data_customcode-6.1.0.dev7 → salesforce_data_customcode-7.0.0rc1}/src/datacustomcode/__init__.py

@@ -13,6 +13,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from datacustomcode.spark.column_hints import install_column_casing_hints
+
+# Friendlier errors for wrong-case column references. Idempotent.
+install_column_casing_hints()
+
 __all__ = [
     "AuthType",
     "Client",

{salesforce_data_customcode-6.1.0.dev7 → salesforce_data_customcode-7.0.0rc1}/src/datacustomcode/config.yaml

@@ -18,6 +18,8 @@ spark_config:
     spark.submit.deployMode: client
     spark.sql.execution.arrow.pyspark.enabled: 'true'
     spark.driver.extraJavaOptions: -Djava.security.manager=allow
+    # Resolve columns case-sensitively so wrong-case refs fail locally too.
+    spark.sql.caseSensitive: 'true'
 
 einstein_predictions_config:
   type_config_name: DefaultEinsteinPredictions

{salesforce_data_customcode-6.1.0.dev7 → salesforce_data_customcode-7.0.0rc1}/src/datacustomcode/deploy.py

@@ -551,15 +551,13 @@ def create_data_transform(
         "version": "56.0",
     }
 
-    # outputDataObjects is only set for DMO-backed transforms. The server requires
-    # the schema of any DMO created/updated by the transform; DLO transforms use
-    # an existing materialized table and must not include this field.
-    if isinstance(data_transform_config.permissions.write, DmoPermission):
-        if not data_transform_config.dataObjects:
+    if not data_transform_config.dataObjects:
+        if isinstance(data_transform_config.permissions.write, DmoPermission):
             raise ValueError(
                 "DMO transforms require 'dataObjects' in config.json describing "
                 "the schema of each output DMO."
             )
+    else:
         definition["outputDataObjects"] = [
             _data_object_to_output(obj) for obj in data_transform_config.dataObjects
         ]

salesforce_data_customcode-7.0.0rc1/src/datacustomcode/spark/column_hints.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2025, Salesforce, Inc.
+# SPDX-License-Identifier: Apache-2
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Friendlier errors when a script references a column by the wrong case.
+
+Data Cloud column names are lowercase. A reference using another case (e.g.
+``df["UnitPrice__c"]``) fails to resolve with a generic error. These hooks
+detect when the lowercase form of a referenced name is a real column and
+prepend an explicit hint, keeping the original message:
+
+    Column 'UnitPrice__c' not found. Did you mean 'unitprice__c'?
+    Data Cloud columns must be lowercase.
+
+Two hooks cover all access paths: one for column-resolution errors, and one
+for attribute access (``df.X``), which fails separately. Both only augment an
+error that was already going to be raised, and only for a pure casing mismatch.
+"""
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Marker on our wrappers so repeated installs never stack.
+_WRAPPED_MARKER = "_datacustomcode_wrapped"
+
+
+def _strip_backticks(name: str) -> str:
+    """Return the bare column name from a Spark identifier token."""
+    name = name.strip()
+    if "." in name:  # drop any table/alias qualifier
+        name = name.split(".")[-1]
+    return name.strip().strip("`")
+
+
+def _casing_hint(bad: str, suggestion: str) -> str:
+    return (
+        f"Column '{bad}' not found. Did you mean '{suggestion}'? "
+        "Data Cloud columns must be lowercase."
+    )
+
+
+def _lowercase_match(bad: str, available: list[str]) -> str | None:
+    """Return the column matching *bad* case-insensitively, else ``None``.
+
+    Returns ``None`` when *bad* is already lowercase, so a real typo is not
+    reported as a casing issue.
+    """
+    if not bad or bad == bad.lower():
+        return None
+    lowered = bad.lower()
+    for col in available:
+        if col.lower() == lowered:
+            return col
+    return None
+
+
+def _install_analysis_exception_hook() -> None:
+    """Add a casing hint to column-resolution errors."""
+    from pyspark.errors.exceptions import captured
+
+    original = captured.convert_exception
+    if getattr(original, _WRAPPED_MARKER, False):
+        return
+
+    def convert_exception_with_hint(e):  # type: ignore[no-untyped-def]
+        exc = original(e)
+        try:
+            error_class = exc.getErrorClass()
+        except Exception:  # pragma: no cover - defensive
+            return exc
+        if not error_class or not error_class.startswith("UNRESOLVED_COLUMN"):
+            return exc
+
+        params = exc.getMessageParameters() or {}
+        bad = _strip_backticks(params.get("objectName", ""))
+        proposal = params.get("proposal", "")
+        available = [
+            _strip_backticks(tok) for tok in proposal.split(",") if tok.strip()
+        ]
+
+        suggestion = _lowercase_match(bad, available)
+        if suggestion is not None:  # prepend hint; keep original detail
+            exc.desc = f"{_casing_hint(bad, suggestion)}\n{exc.desc}"
+        return exc
+
+    setattr(convert_exception_with_hint, _WRAPPED_MARKER, True)
+    captured.convert_exception = convert_exception_with_hint
+
+
+def _install_getattr_hook() -> None:
+    """Add a casing hint to attribute access (``df.X``)."""
+    from pyspark.sql import DataFrame
+
+    original = DataFrame.__getattr__
+    if getattr(original, _WRAPPED_MARKER, False):
+        return
+
+    def __getattr__with_hint(self, name):  # type: ignore[no-untyped-def]
+        try:
+            return original(self, name)
+        except AttributeError as exc:
+            if name.startswith("_"):  # leave dunder/private lookups alone
+                raise
+            suggestion = _lowercase_match(name, list(self.columns))
+            if suggestion is not None:  # prepend hint; keep original text
+                raise AttributeError(
+                    f"{_casing_hint(name, suggestion)}\n{exc}"
+                ) from None
+            raise
+
+    setattr(__getattr__with_hint, _WRAPPED_MARKER, True)
+    DataFrame.__getattr__ = __getattr__with_hint  # type: ignore[assignment]
+
+
+def install_column_casing_hints() -> None:
+    """Install the column-casing hint hooks. Idempotent; never raises."""
+    try:
+        _install_analysis_exception_hook()
+        _install_getattr_hook()
+    except Exception as exc:  # pragma: no cover - defensive
+        logger.debug(f"Could not install column-casing hint hooks: {exc}")

salesforce_data_customcode-6.1.0.dev7/src/datacustomcode/templates/function/example/chunking_with_external_callout/README.md

@@ -1,120 +0,0 @@
-# Chunking with a Gemini Named Credential Callout
-
-Splits each input document into paragraph-sized chunks and calls Google's
-**Gemini** `generateContent` API for every chunk. The model returns a summary,
-category, sentiment, and topics, which are attached to the chunk as citations so
-the search index can filter and rank on them. Gemini is reached through a
-**Named Credential**, so this code never handles the endpoint URL or the API key.
-
-## How the callout works
-
-```python
-CALLOUT_URL = "callout:gemini"  # callout:<NC name>[/<path>]
-
-request = (
-    HTTPRequestBuilder()
-    .set_url(CALLOUT_URL)
-    .set_method(HTTPMethod.POST)
-    .set_headers({"Content-Type": "application/json"})
-    .set_response_timeout_seconds(60) # optional: per-callout timeout (seconds)
-    .build()
-)
-# Body is sent verbatim (serialize it yourself); the response body is a raw string.
-response = runtime.named_credential.request(request, json.dumps(payload))
-if response.is_success:
-    envelope = json.loads(response.body)
-    text = envelope["candidates"][0]["content"]["parts"][0]["text"]
-```
-
-The request asks for `responseMimeType: application/json` with a `responseSchema`,
-so Gemini returns the classification as a JSON string in
-`candidates[0].content.parts[0].text` — decode it, then decode that text again.
-
-The `gemini` Named Credential's URL already includes the full
-`/v1beta/models/<model>:generateContent` path, so the callout is just
-`callout:gemini` with **no path suffix** (anything after the name is appended to
-the credential's URL).
-
-## Configure the Named Credential
-
-1. Create an **External Credential** (e.g. `google_api_key`) that injects your
-   Gemini API key as the `X-goog-api-key` header.
-2. Create a **Named Credential** named `gemini`:
-   - **URL**: `https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent`
-   - **Enabled for Callouts** + **Generate Authorization Header**: on
-   - **External Credential**: `google_api_key`
-
-## Test locally
-
-```bash
-DATACUSTOMCODE_EXTERNAL_CALLOUT_CONFIG=/abs/path/to/external_callout_config.json \
-  sf data-code-extension function run \
-    --entrypoint payload/entrypoint.py \
-    --test-with payload/tests/test.json \
-    --target-org <your-org-alias>
-```
-
-With `--target-org` the SDK fetches only the **URL** from the org's Named
-Credential; **auth is always taken from `external_callout_config.json`** locally
-(the org's External Credential is used only in the Data Cloud runtime). So the
-`X-goog-api-key` must be in the local config for a local test. Omit
-`--target-org` to run fully offline using `target_url`.
-
-```json
-{
-    "credentials": {
-        "callout:gemini": {
-            "auth_type": "Custom",
-            "custom_headers": { "X-goog-api-key": "YOUR_GEMINI_API_KEY" },
-            "target_url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent"
-        }
-    }
-}
-```
-
-Place `external_callout_config.json` in the **parent of your payload folder** (or
-point `DATACUSTOMCODE_EXTERNAL_CALLOUT_CONFIG` at it). It is never packaged into
-the deployment zip. Get a key from [Google AI Studio](https://aistudio.google.com/apikey);
-**do not commit it.**
-
-## Auth types
-
-`auth_type` selects how auth is injected for local testing. It should mirror the
-External Credential your Named Credential uses in the org, so local and deployed
-runs behave the same. This example uses `Custom` (Gemini's `X-goog-api-key`);
-all four supported types:
-
-```json
-{
-    "credentials": {
-        "callout:my_custom_api": {
-            "auth_type": "Custom",
-            "custom_headers": { "X-goog-api-key": "YOUR_API_KEY" }
-        },
-        "callout:my_basic_api": {
-            "auth_type": "Basic",
-            "username": "svc_user",
-            "password": "YOUR_PASSWORD"
-        },
-        "callout:my_oauth_api": {
-            "auth_type": "OAuth",
-            "access_token": "YOUR_ACCESS_TOKEN"
-        },
-        "callout:my_jwt_api": {
-            "auth_type": "Jwt",
-            "token": "YOUR_JWT"
-        }
-    }
-}
-```
-
-| `auth_type` | Fields read | Header sent |
-| ----------- | ------------------------------- | --------------------------------------- |
-| `Basic`     | `username`, `password`          | `Authorization: Basic <base64 user:pw>` |
-| `Custom`    | `custom_headers` (sent verbatim)| the headers you list                    |
-| `OAuth`     | `access_token` or `token`       | `Authorization: Bearer <token>`         |
-| `Jwt`       | `access_token` or `token`       | `Authorization: Bearer <token>`         |
-
-`OAuth`/`Jwt` take a token you supply for the local run — the SDK does not fetch
-or refresh it. In the Data Cloud runtime the Named Credential handles token
-acquisition; this local config only stands in for that during testing.

salesforce_data_customcode-6.1.0.dev7/src/datacustomcode/templates/function/example/chunking_with_external_callout/entrypoint.py

@@ -1,162 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-
-"""
-Document Chunking with a Gemini Named Credential Callout
-
-Splits each input document into paragraph-sized chunks and classifies every
-chunk via Google's Gemini ``generateContent`` API, reached through a Named
-Credential (``callout:gemini``) so the endpoint URL and API key are resolved
-outside this code. The classification is attached to each chunk as citations.
-"""
-
-import json
-import logging
-
-from datacustomcode.function import Runtime
-from datacustomcode.function.feature_types.chunking import (
-    ChunkType,
-    SearchIndexChunkingV1Output,
-    SearchIndexChunkingV1Request,
-    SearchIndexChunkingV1Response,
-)
-from datacustomcode.named_credential.types.http_method import HTTPMethod
-from datacustomcode.named_credential.types.http_request_builder import (
-    HTTPRequestBuilder,
-)
-
-logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)
-
-CALLOUT_URL = "callout:gemini"
-
-_ANALYSIS_FIELDS = ("summary", "category", "sentiment")
-
-_PROMPT = (
-    "Analyze the following document chunk and classify it. Respond with its "
-    "one-sentence summary, a single-word category, overall sentiment "
-    "(positive, negative, or neutral), and up to five key topics.\n\nChunk:\n"
-)
-
-# Force Gemini to return the classification as JSON in a fixed shape.
-_GENERATION_CONFIG = {
-    "responseMimeType": "application/json",
-    "responseSchema": {
-        "type": "object",
-        "properties": {
-            "summary": {"type": "string"},
-            "category": {"type": "string"},
-            "sentiment": {"type": "string"},
-            "topics": {"type": "array", "items": {"type": "string"}},
-        },
-        "required": ["summary", "category", "sentiment", "topics"],
-    },
-}
-
-
-def _chunk_text(text: str, max_words: int = 80) -> list[str]:
-    """Split text into paragraph-aligned chunks of at most ``max_words`` words."""
-    paragraphs = [p.strip() for p in text.split("\n\n") if p.strip()]
-
-    chunks: list[str] = []
-    current: list[str] = []
-    current_words = 0
-
-    for paragraph in paragraphs:
-        paragraph_words = len(paragraph.split())
-        if current and current_words + paragraph_words > max_words:
-            chunks.append("\n\n".join(current))
-            current = []
-            current_words = 0
-        current.append(paragraph)
-        current_words += paragraph_words
-
-    if current:
-        chunks.append("\n\n".join(current))
-
-    return chunks
-
-
-def _extract_model_json(body: str) -> dict:
-    """Decode the model's JSON classification from a Gemini response.
-
-    The generated text sits at ``candidates[0].content.parts[0].text`` and is
-    itself a JSON string, so decode twice. Any malformed layer yields ``{}``.
-    """
-    try:
-        envelope = json.loads(body) if body else {}
-    except json.JSONDecodeError:
-        return {}
-
-    try:
-        text = envelope["candidates"][0]["content"]["parts"][0]["text"]
-    except (KeyError, IndexError, TypeError):
-        return {}
-
-    try:
-        payload = json.loads(text)
-    except json.JSONDecodeError:
-        return {}
-    return payload if isinstance(payload, dict) else {}
-
-
-def _analyze_chunk(chunk_text: str, runtime: Runtime) -> dict[str, str]:
-    """Classify one chunk via the Gemini callout and return it as citations."""
-    request = (
-        HTTPRequestBuilder()
-        .set_url(CALLOUT_URL)
-        .set_method(HTTPMethod.POST)
-        .set_headers({"Content-Type": "application/json", "Accept": "application/json"})
-        .set_response_timeout_seconds(60)
-        .build()
-    )
-
-    payload = {
-        "contents": [{"parts": [{"text": _PROMPT + chunk_text}]}],
-        "generationConfig": _GENERATION_CONFIG,
-    }
-    response = runtime.named_credential.request(request, json.dumps(payload))
-
-    # Don't raise: a single failed callout shouldn't abort the whole job.
-    if not response.is_success:
-        logger.error(f"Gemini callout failed with status {response.status_code}")
-        return {"analysis_status": "failed", "http_status": str(response.status_code)}
-
-    data = _extract_model_json(response.body)
-    citations = {"analysis_status": "success"}
-    for field in _ANALYSIS_FIELDS:
-        value = data.get(field)
-        citations[field] = str(value) if value is not None else "unavailable"
-
-    topics = data.get("topics")
-    if isinstance(topics, list):
-        citations["topics"] = ", ".join(str(topic) for topic in topics)
-
-    return citations
-
-
-def function(
-    request: SearchIndexChunkingV1Request, runtime: Runtime
-) -> SearchIndexChunkingV1Response:
-    """Chunk each input document and classify every chunk via the Gemini API."""
-    logger.info(f"Received {len(request.input)} documents to chunk")
-
-    chunks = []
-    chunk_id = 1
-
-    for doc in request.input:
-        for chunk_text in _chunk_text(doc.text):
-            citations = _analyze_chunk(chunk_text, runtime)
-
-            chunk = SearchIndexChunkingV1Output(
-                text=chunk_text,
-                seq_no=chunk_id,
-                chunk_type=ChunkType.TEXT,
-                citations=citations,
-            )
-            chunks.append(chunk)
-            chunk_id += 1
-
-    logger.info(f"Produced {len(chunks)} classified chunks")
-    return SearchIndexChunkingV1Response(output=chunks)

salesforce_data_customcode-6.1.0.dev7/src/datacustomcode/templates/function/example/chunking_with_external_callout/external_callout_config.json

@@ -1,11 +0,0 @@
-{
-    "credentials": {
-        "callout:gemini": {
-            "auth_type": "Custom",
-            "custom_headers": {
-                "X-goog-api-key": "YOUR_API_KEY"
-            },
-            "target_url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent"
-        }
-    }
-}

salesforce_data_customcode-6.1.0.dev7/src/datacustomcode/templates/function/example/chunking_with_external_callout/tests/test.json

@@ -1,16 +0,0 @@
-{
-    "input": [
-        {
-            "text": "Product Review: Northstar Analytics\n\nWe rolled Northstar out to our whole revenue team last quarter and the difference has been night and day. Dashboards that used to take our analysts a full day to assemble now refresh in seconds, and the natural-language query box means our account executives can answer their own questions without filing a ticket.\n\nOnboarding was smoother than any tool we have adopted in years. The guided setup imported our Salesforce data on the first try and the sample templates gave us something useful on day one. Support answered our two questions within the hour. Easily the best purchase decision we made this year."
-        },
-        {
-            "text": "Support Ticket #48210: Repeated timeouts on scheduled exports\n\nFor the third week running our nightly export to the data warehouse has failed silently. There is no alert, no email, nothing in the activity log, and we only find out when the morning report is empty and the leadership meeting has no numbers.\n\nI have raised this twice already and both times the ticket was closed as resolved without anyone actually contacting me. This is costing us real credibility internally and I am extremely frustrated. If the connector cannot handle our volume we need to know now so we can plan a migration, because right now the product is not doing the one job we bought it for."
-        },
-        {
-            "text": "Renewal Feedback: mixed feelings heading into year two\n\nThe core product is genuinely good. The reporting engine is fast, the permissions model is granular enough for our compliance team, and our analysts like working in it. On the functionality alone I would renew without hesitation.\n\nWhat gives me pause is the pricing. The per-seat cost jumped noticeably at renewal and several add-ons that used to be included are now separate line items. The value is still there, but the conversation with my finance team was harder than it should have been, and I would like more transparency before the next cycle."
-        },
-        {
-            "text": "Feature Request: scheduled report subscriptions\n\nWe would like the ability to subscribe internal stakeholders to a report on a recurring schedule so a PDF lands in their inbox every Monday morning. Today we export manually and forward it, which is workable but easy to forget.\n\nA few teams have asked whether subscriptions could support filtered views per recipient, for example each regional manager receiving only their own territory. Not urgent for us, but it would remove a recurring bit of manual work and is something a couple of competing tools already offer."
-        }
-    ]
-}

salesforce_data_customcode-6.1.0.dev7/src/datacustomcode/templates/function/example/chunking_with_prediction/config.json

@@ -1,3 +0,0 @@
-{
-    "entryPoint": "entrypoint.py"
-}

salesforce_data_customcode-6.1.0.dev7/src/datacustomcode/templates/script/examples/external_callout/README.md

@@ -1,140 +0,0 @@
-# Transform with a Gemini Named Credential Callout
-
-The **transform** calls Google's **Gemini** `generateContent` API to summarize text, and
-write the result back to a DLO. Gemini is reached through a **Named Credential**
-(`callout:gemini`), so this code never handles the endpoint URL or the API key.
-
-It shows **both** callout paths against the same Named Credential.
-
-## Shared request template
-
-```python
-from datacustomcode.client import Client, named_credential_request_col
-
-# URL, method and headers apply to every callout on this template.
-request = (
-    HTTPRequestBuilder()
-    .set_url("callout:gemini")            # callout:<NC name>[/<path>]
-    .set_method(HTTPMethod.POST)
-    .set_headers({"Content-Type": "application/json"})
-    .set_response_timeout_seconds(60)     # optional: per-callout timeout (seconds)
-    .build()
-)
-```
-
-## Driver path — one-shot on the driver
-
-`Client.named_credential_request` runs the callout **once** on the driver and
-returns an `HTTPResponse` (`.status_code`, `.body`, `.headers`, `.is_success`).
-Use it for a lookup or a shared value you reuse across the job.
-
-```python
-response = client.named_credential_request(request, body=json.dumps(payload))
-if response.is_success:
-    envelope = json.loads(response.body)
-    text = envelope["candidates"][0]["content"]["parts"][0]["text"]
-```
-
-## Per-row path — fan out across the DataFrame
-
-`named_credential_request_col` dispatches one callout per row; only the body
-Column varies.
-
-```python
-# One callout per row; body is a Column built from the row's data.
-df = df.withColumn("_callout", named_credential_request_col(request, body=body_col))
-```
-
-It returns a struct Column:
-
-```
-{status, response: {status_code, body, headers}, error_code, error_message}
-```
-
-- A non-2xx response is still `status = "SUCCESS"` with the HTTP code in
-  `response.status_code` — extracting the model text just yields null for that row.
-- A transport failure sets `status = "ERROR"`; the row survives, the job does not
-  abort. Pull the model text out of `response.body` with `get_json_object(...)`.
-
-Both paths resolve the same Named Credential and read auth from the same local
-`external_callout_config.json`.
-
-The `gemini` Named Credential's URL already includes the full
-`/v1beta/models/<model>:generateContent` path, so the callout is just
-`callout:gemini` with **no path suffix** (anything after the name is appended to
-the credential's URL).
-
-## Configure the Named Credential
-
-1. Create an **External Credential** (e.g. `google_api_key`) that injects your
-   Gemini API key as the `X-goog-api-key` header.
-2. Create a **Named Credential** named `gemini`:
-   - **URL**: `https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent`
-   - **Enabled for Callouts** + **Generate Authorization Header**: on
-   - **External Credential**: `google_api_key`
-
-## Test locally
-
-Copy `entrypoint.py` into your `payload/` folder (or point the run at it), then:
-
-```bash
-DATACUSTOMCODE_EXTERNAL_CALLOUT_CONFIG=/abs/path/to/external_callout_config.json \
-  sf data-code-extension script run --entrypoint entrypoint.py --target-org <your-org-alias>
-```
-
-With `----target-org` the SDK fetches only the **URL** from the org's Named
-Credential; **auth is always taken from `external_callout_config.json`** locally
-(the org's External Credential is used only in the Data Cloud runtime). So the
-`X-goog-api-key` must be in the local config for a local test. Omit
-`--target-org` to run fully offline using `target_url`.
-
-```json
-{
-    "credentials": {
-        "callout:gemini": {
-            "auth_type": "Custom",
-            "custom_headers": { "X-goog-api-key": "YOUR_GEMINI_API_KEY" },
-            "target_url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent"
-        }
-    }
-}
-```
-
-Place `external_callout_config.json` in the **parent of your payload folder** (or
-point `DATACUSTOMCODE_EXTERNAL_CALLOUT_CONFIG` at it). It is never packaged into
-the deployment zip. Get a key from [Google AI Studio](https://aistudio.google.com/apikey);
-**do not commit it.**
-
-## What it reads / writes
-
-`config.json` declares the DLO permissions for deployment:
-
-| | DLO | Notes |
-| ------ | ------------------- | --------------------------------------------- |
-| read   | `Account_std__dll`  | source rows; `description__c` is summarized   |
-| write  | `Account_std_copy__dll` | adds `summary__c`, `callout_status__c`, `callout_http_code__c` |
-
-Adjust `_TEXT_COLUMN`, `_SOURCE_DLO` and `_TARGET_DLO` in `entrypoint.py` (and the
-matching entries in `config.json`) to point at your own DLOs.
-
-## Auth types
-
-`auth_type` selects how auth is injected for local testing. It should mirror the
-External Credential your Named Credential uses in the org, so local and deployed
-runs behave the same. This example uses `Custom` (Gemini's `X-goog-api-key`);
-all supported types:
-
-| `auth_type` | Fields read | Header sent |
-| ----------- | ------------------------------- | --------------------------------------- |
-| `Basic`     | `username`, `password`          | `Authorization: Basic <base64 user:pw>` |
-| `Custom`    | `custom_headers` (sent verbatim)| the headers you list                    |
-| `OAuth`     | `access_token` or `token`       | `Authorization: Bearer <token>`         |
-| `Jwt`       | `access_token` or `token`       | `Authorization: Bearer <token>`         |
-| `AwsSv4`    | `aws_access_key_id`, `aws_secret_access_key`, `aws_region`, `aws_service`, optional `aws_session_token` | `Authorization: AWS4-HMAC-SHA256 ...` plus `x-amz-date` / `x-amz-content-sha256` (and `x-amz-security-token` when a session token is set) |
-
-`OAuth`/`Jwt` take a token you supply for the local run — the SDK does not fetch
-or refresh it. In the Data Cloud runtime the Named Credential handles token
-acquisition; this local config only stands in for that during testing.
-
-`AwsSv4` signs the request with AWS Signature Version 4 using the keys you
-supply, mirroring an AWS Signature Version 4 External Credential in the org.